fix(autoresearch): resume bound decomposition directly

Bypass legacy candidate novelty only for fully target-bound Research Contract decomposition resumes, with a typed evidence backjump for the prior misclassification.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: 2 people

autoresearch/prefill/supervisor.py

@@ -39,6 +39,7 @@
 from autoresearch.prefill.cursor_strategy import CursorStrategyAdapter
 from autoresearch.prefill.strategy_tournament import StrategyEvent
 from autoresearch.prefill.orchestration_state import (
+    BlockedEventType,
     BlockedExitEvent,
     OrchestrationCheckpoint,
     ProofState,
@@ -1696,6 +1697,73 @@ def route_contract_to_subgoal_generation(
     return True
 
 
+def is_contract_bound_subgoal_resume(
+    checkpoint: OrchestrationCheckpoint | None,
+) -> bool:
+    """Recognize a typed decomposition resume independent of wrapper candidate."""
+    return bool(
+        checkpoint is not None
+        and checkpoint.proof_state == ProofState.DECOMPOSER
+        and checkpoint.target_obligation_id
+        and checkpoint.proposition_hash
+        and checkpoint.target_context_hash
+        and checkpoint.selected_strategy_plan_id
+        and checkpoint.research_contract_id
+        and not checkpoint.adapter_status
+    )
+
+
+def recover_contract_subgoal_duplicate_block(
+    checkpoint: OrchestrationCheckpoint | None,
+) -> BlockedExitEvent | None:
+    """Repair only the legacy novelty block on a bound decomposition resume."""
+    duplicate_reason = (
+        "Strategy proposals were duplicates; reuse the current candidate "
+        "and unresolved role."
+    )
+    if (
+        checkpoint is None
+        or checkpoint.proof_state != ProofState.BLOCKED
+        or checkpoint.blocked_reason != duplicate_reason
+        or checkpoint.proof_plan_id
+        or checkpoint.executable_plan_node_id
+        or not checkpoint.research_contract_id
+        or not checkpoint.selected_strategy_plan_id
+        or not checkpoint.target_context_hash
+    ):
+        return None
+    evidence = next(
+        (
+            str(item.get("event_id", ""))
+            for item in reversed(checkpoint.recovery_events)
+            if item.get("event_type") == "RESEARCH_CONTRACT_SUBGOAL_REQUIRED"
+            and item.get("target_obligation_id")
+            == checkpoint.target_obligation_id
+            and item.get("research_contract_id")
+            == checkpoint.research_contract_id
+        ),
+        "",
+    )
+    if not evidence:
+        return None
+    event = BlockedExitEvent(
+        event_id=hashlib.sha256(
+            (
+                "contract-subgoal-duplicate-recovery:"
+                + evidence
+                + checkpoint.target_context_hash
+            ).encode()
+        ).hexdigest(),
+        event_type=BlockedEventType.VALIDATED_EVIDENCE_BACKJUMP.value,
+        reason="target-bound decomposition bypasses candidate novelty",
+        target_state=ProofState.DECOMPOSER.value,
+        reset_role=ProofState.DECOMPOSER.value,
+        metadata={"evidence_sha256": evidence},
+    )
+    apply_blocked_exit_event(checkpoint, event)
+    return event
+
+
 def should_resume_downstream(
     checkpoint: OrchestrationCheckpoint | None,
     *,
@@ -1705,9 +1773,12 @@ def should_resume_downstream(
 ) -> bool:
     """Keep a persisted role unless an explicit Strategy policy overrides it."""
     return bool(
-        is_resumable_checkpoint(
-            checkpoint,
-            candidate_sha256=candidate_sha256,
+        (
+            is_resumable_checkpoint(
+                checkpoint,
+                candidate_sha256=candidate_sha256,
+            )
+            or is_contract_bound_subgoal_resume(checkpoint)
         )
         and not (
             checkpoint is not None
@@ -3065,6 +3136,28 @@ def run_supervisor_iterations(args) -> int:
                 cause=event.event_type,
                 event_id=event.event_id,
             )
+        recovered_event = recover_contract_subgoal_duplicate_block(checkpoint)
+        if recovered_event is not None and orchestration_path is not None:
+            save_orchestration_checkpoint(orchestration_path, checkpoint)
+            append_blocked_event_journal(
+                orchestration_path.with_name(
+                    "proof_orchestration.journal.jsonl",
+                ),
+                recovered_event,
+                before_state=ProofState.BLOCKED.value,
+                after_state=checkpoint.state,
+            )
+            blocked_logger.transition(
+                next_state=checkpoint.state,
+                cause=recovered_event.event_type,
+                event_id=recovered_event.event_id,
+            )
+            print(
+                "[proof-live] stage=backjump "
+                "from=BLOCKED to=DECOMPOSER "
+                "reason=target-bound-candidate-novelty-bypass",
+                flush=True,
+            )
         if (
             checkpoint is not None
             and route_contract_to_subgoal_generation(checkpoint)

tests/inference_engine/bench/test_autoresearch_supervisor.py

@@ -40,12 +40,14 @@
     extract_gan_failure_reason,
     failure_class_for_exception,
     infrastructure_failure_fingerprint,
+    is_contract_bound_subgoal_resume,
     is_resumable_checkpoint,
     is_nonfatal_semantic_continuation,
     parse_strategy_candidate_transport,
     parse_research_verdict,
     read_results,
     repair_candidate_schema,
+    recover_contract_subgoal_duplicate_block,
     render_candidate,
     route_contract_to_subgoal_generation,
     run_supervisor_iterations,
@@ -100,6 +102,56 @@ def test_contract_with_executable_subgoal_does_not_backjump():
     assert checkpoint.proof_state == ProofState.PROOF_SEARCH
 
 
+def test_target_bound_decomposer_resume_ignores_wrapper_candidate_hash():
+    checkpoint = OrchestrationCheckpoint(
+        state=ProofState.DECOMPOSER.value,
+        current_role="decomposer",
+        target_obligation_id="RH-C0-root",
+        proposition_hash="p" * 64,
+        target_context_hash="c" * 64,
+        selected_strategy_plan_id="SP-root",
+        research_contract_id="RC-root",
+        candidate_sha256="",
+    )
+    assert is_contract_bound_subgoal_resume(checkpoint)
+    assert should_resume_downstream(
+        checkpoint,
+        candidate_sha256="different-wrapper-hash",
+        force_strategy=False,
+        strategy_trigger_exists=False,
+    )
+
+
+def test_duplicate_wrapper_block_recovers_bound_decomposer():
+    checkpoint = OrchestrationCheckpoint(
+        state=ProofState.BLOCKED.value,
+        current_role="blocked",
+        target_obligation_id="RH-C0-root",
+        proposition_hash="p" * 64,
+        target_context_hash="c" * 64,
+        selected_strategy_plan_id="SP-root",
+        research_contract_id="RC-root",
+        blocked_reason=(
+            "Strategy proposals were duplicates; reuse the current candidate "
+            "and unresolved role."
+        ),
+        recovery_events=[{
+            "event_type": "RESEARCH_CONTRACT_SUBGOAL_REQUIRED",
+            "event_id": "e" * 64,
+            "target_obligation_id": "RH-C0-root",
+            "research_contract_id": "RC-root",
+        }],
+    )
+    event = recover_contract_subgoal_duplicate_block(checkpoint)
+    assert event is not None
+    assert event.event_type == (
+        BlockedEventType.VALIDATED_EVIDENCE_BACKJUMP.value
+    )
+    assert checkpoint.proof_state == ProofState.DECOMPOSER
+    assert checkpoint.blocked_reason == ""
+    assert recover_contract_subgoal_duplicate_block(checkpoint) is None
+
+
 def test_live_status_atomic_transitions_and_permissions(tmp_path):
     path = tmp_path / "proof_live_status.json"
     status = AtomicLiveStatus(