fix(autoresearch): make formal root binding canonical

Derive mutable research-goal caches from the formalized ledger root and fail closed on true binding mismatches without discarding accepted contract provenance.

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

Author: 2 people

autoresearch/prefill/supervisor.py

@@ -1791,6 +1791,92 @@ def route_contract_to_subgoal_generation(
     return True
 
 
+def reconcile_canonical_root_binding(
+    checkpoint: OrchestrationCheckpoint,
+    ledger: dict,
+    *,
+    state_path: Path,
+) -> bool:
+    """Derive mutable root caches from the formalized ledger root."""
+    obligation = next(
+        (
+            item for item in ledger.get("obligations", ())
+            if item.get("obligation_id") == checkpoint.target_obligation_id
+        ),
+        None,
+    )
+    if obligation is None:
+        raise ValueError("CANONICAL_ROOT_OBLIGATION_MISSING")
+    proposition_hash = str(obligation.get("proposition_hash", ""))
+    signature_hash = str(obligation.get("lean_signature_hash", ""))
+    canonical_hash = proposition_hash or signature_hash
+    statement = str(obligation.get("statement", ""))
+    if (
+        obligation.get("parent_id")
+        or obligation.get("formal_status") != "FORMALIZED"
+        or len(canonical_hash) != 64
+        or hashlib.sha256(statement.encode()).hexdigest() != canonical_hash
+    ):
+        raise ValueError("CANONICAL_ROOT_BINDING_INVALID")
+    protected = {
+        "proposition_hash": checkpoint.proposition_hash,
+        "parent_statement_sha256": checkpoint.parent_statement_sha256,
+        "parent_signature_sha256": checkpoint.parent_signature_sha256,
+    }
+    if any(
+        value and value != canonical_hash for value in protected.values()
+    ):
+        raise ValueError("CANONICAL_ROOT_PROPOSITION_MISMATCH")
+    try:
+        cached = json.loads(state_path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        cached = {"schema_version": 1}
+    if not isinstance(cached, dict):
+        raise ValueError("DERIVED_ROOT_GOAL_CACHE_INVALID")
+    changed = any((
+        checkpoint.root_goal_sha256 != canonical_hash,
+        checkpoint.proposition_hash != canonical_hash,
+        checkpoint.parent_statement_sha256 != canonical_hash,
+        checkpoint.parent_signature_sha256 != canonical_hash,
+        checkpoint.target_statement != statement,
+        ledger.get("root_goal_hash") != canonical_hash,
+        cached.get("research_goal") != statement,
+    ))
+    if not changed:
+        return False
+    checkpoint.root_goal_sha256 = canonical_hash
+    checkpoint.proposition_hash = canonical_hash
+    checkpoint.parent_statement_sha256 = canonical_hash
+    checkpoint.parent_signature_sha256 = canonical_hash
+    checkpoint.target_statement = statement
+    ledger["root_goal_hash"] = canonical_hash
+    cached["research_goal"] = statement
+    cached.setdefault("schema_version", 1)
+    encoded = json.dumps(cached, indent=2, ensure_ascii=False) + "\n"
+    temporary = state_path.with_name(
+        f".{state_path.name}.{os.getpid()}.canonical-root.tmp",
+    )
+    temporary.write_text(encoded, encoding="utf-8")
+    os.chmod(temporary, 0o600)
+    os.replace(temporary, state_path)
+    checkpoint.recovery_events.append({
+        "event_type": "CANONICAL_ROOT_BINDING_RECONCILED",
+        "event_id": hashlib.sha256(
+            (
+                checkpoint.target_obligation_id
+                + canonical_hash
+                + checkpoint.research_contract_id
+            ).encode()
+        ).hexdigest(),
+        "target_obligation_id": checkpoint.target_obligation_id,
+        "proposition_hash": canonical_hash,
+        "research_contract_id": checkpoint.research_contract_id,
+        "derived_cache": str(state_path.name),
+        "created_at": time.time(),
+    })
+    return True
+
+
 def is_contract_bound_subgoal_resume(
     checkpoint: OrchestrationCheckpoint | None,
 ) -> bool:
@@ -2277,6 +2363,31 @@ def run_iteration(args, iteration: int) -> dict:
     orchestration_checkpoint = load_orchestration_checkpoint(
         orchestration_state_path,
     )
+    normalized_ledger = asdict(ledger_object)
+    canonical_target = next(
+        (
+            item for item in normalized_ledger.get("obligations", ())
+            if item.get("obligation_id")
+            == (
+                orchestration_checkpoint.target_obligation_id
+                if orchestration_checkpoint is not None else ""
+            )
+        ),
+        {},
+    )
+    if (
+        orchestration_checkpoint is not None
+        and canonical_target.get("proposition_hash")
+        and reconcile_canonical_root_binding(
+            orchestration_checkpoint,
+            normalized_ledger,
+            state_path=state_path,
+        )
+    ):
+        save_orchestration_checkpoint(
+            orchestration_state_path,
+            orchestration_checkpoint,
+        )
     if (
         orchestration_checkpoint is not None
         and ledger_object is not None

scripts/agent_gan_repl.py

@@ -5344,7 +5344,57 @@ def run_certified_decomposition(
                 ledger_id=ledger.ledger_id,
                 ledger_version=ledger.version,
             )
-        if orchestration_checkpoint is None or mismatch:
+        if orchestration_checkpoint is not None and mismatch:
+            orchestration_checkpoint.adapter_blocked(
+                "CANONICAL_BINDING_OWNERSHIP_REQUIRED:" + mismatch,
+                status="INTEGRATION_BLOCKED",
+            )
+            orchestration_checkpoint.recovery_events.append({
+                "event_type": "CANONICAL_BINDING_MISMATCH_REJECTED",
+                "event_id": (
+                    "canonical-binding-mismatch:"
+                    + hashlib.sha256(
+                        (
+                            mismatch
+                            + orchestration_checkpoint.target_obligation_id
+                            + orchestration_checkpoint.proposition_hash
+                        ).encode()
+                    ).hexdigest()[:20]
+                ),
+                "reason": mismatch,
+                "preserved_artifact_hashes": sorted(
+                    reference.sha256
+                    for reference
+                    in orchestration_checkpoint.validated_artifacts.values()
+                ),
+                "preserved_research_contract_id": (
+                    orchestration_checkpoint.research_contract_id
+                ),
+                "created_at": time.time(),
+            })
+            save_orchestration_checkpoint(
+                checkpoint_path,
+                orchestration_checkpoint,
+            )
+            return DecompositionCertificateResult(
+                verified=False,
+                errors=[
+                    "CANONICAL_BINDING_OWNERSHIP_REQUIRED:" + mismatch,
+                ],
+                artifacts={},
+                artifact_hashes={},
+                transcripts={},
+                role_run_ids={},
+                validation={
+                    "host_gates_passed": False,
+                    "blocked": True,
+                    "failure_status": "INTEGRATION_BLOCKED",
+                    "preserved_research_contract_id": (
+                        orchestration_checkpoint.research_contract_id
+                    ),
+                },
+            )
+        if orchestration_checkpoint is None:
             previous_checkpoint = orchestration_checkpoint
             orchestration_checkpoint = OrchestrationCheckpoint(
                 state=ProofState.DEFINITION_AUDITOR.value,
@@ -8845,6 +8895,16 @@ def get_stats():
                     decomposition_target = (
                         resume_checkpoint.target_obligation_id
                     )
+                    canonical_root_goal = next(
+                        item.statement for item in proof_ledger.obligations
+                        if item.obligation_id == decomposition_target
+                        and not item.parent_id
+                        and item.formal_status == "FORMALIZED"
+                        and (
+                            item.proposition_hash
+                            or item.lean_signature_hash
+                        ) == resume_checkpoint.proposition_hash
+                    )
                     target_ids = {decomposition_target}
                     isolated_role_stages = []
 
@@ -8891,7 +8951,7 @@ def direct_review_role(
                     certificate = run_certified_decomposition(
                         proof_ledger,
                         decomposition_target,
-                        research_goal,
+                        canonical_root_goal,
                         direct_review_role,
                         project_root=Path(__file__).resolve().parents[1],
                         orchestration_id=orchestration_id,

tests/inference_engine/bench/test_autoresearch_supervisor.py

@@ -1,6 +1,8 @@
+import hashlib
 import json
 import os
 import pytest
+from dataclasses import asdict
 from types import SimpleNamespace
 
 from autoresearch.prefill.live_status import AtomicLiveStatus
@@ -46,6 +48,7 @@
     parse_strategy_candidate_transport,
     parse_research_verdict,
     read_results,
+    reconcile_canonical_root_binding,
     repair_research_contract_artifact_dependency,
     repair_candidate_schema,
     recover_contract_subgoal_duplicate_block,
@@ -182,6 +185,92 @@ def test_research_contract_dependency_repairs_to_artifact_hash(tmp_path):
     assert not repair_research_contract_artifact_dependency(checkpoint)
 
 
+def test_stale_root_goal_cache_reconciles_without_losing_contract(tmp_path):
+    canonical = hashlib.sha256(b"RiemannHypothesis").hexdigest()
+    state_path = tmp_path / "agent_state.json"
+    state_path.write_text(json.dumps({
+        "schema_version": 1,
+        "research_goal": "stale Hilbert-Polya cache",
+    }))
+    ledger = {
+        "ledger_id": "rh",
+        "version": 96,
+        "obligations": [{
+            "obligation_id": "RH-C0-root",
+            "statement": "RiemannHypothesis",
+            "status": "UNRESOLVED",
+            "parent_id": "",
+            "formal_status": "FORMALIZED",
+            "lean_signature_hash": canonical,
+            "proposition_hash": canonical,
+        }],
+    }
+    checkpoint = OrchestrationCheckpoint(
+        state=ProofState.DECOMPOSER.value,
+        current_role="decomposer",
+        target_obligation_id="RH-C0-root",
+        target_statement="RiemannHypothesis",
+        proposition_hash=canonical,
+        parent_statement_sha256=canonical,
+        parent_signature_sha256=canonical,
+        root_goal_sha256=hashlib.sha256(b"stale").hexdigest(),
+        selected_strategy_plan_id="SP-root",
+        research_contract_id="RC-root",
+        research_contract_hash="contract-hash",
+    )
+    assert reconcile_canonical_root_binding(
+        checkpoint,
+        ledger,
+        state_path=state_path,
+    )
+    assert checkpoint.root_goal_sha256 == canonical
+    assert checkpoint.research_contract_id == "RC-root"
+    assert checkpoint.research_contract_hash == "contract-hash"
+    assert ledger["root_goal_hash"] == canonical
+    assert json.loads(state_path.read_text())["research_goal"] == (
+        "RiemannHypothesis"
+    )
+    assert not reconcile_canonical_root_binding(
+        checkpoint,
+        ledger,
+        state_path=state_path,
+    )
+
+
+def test_true_canonical_proposition_mismatch_preserves_checkpoint(tmp_path):
+    canonical = hashlib.sha256(b"RiemannHypothesis").hexdigest()
+    state_path = tmp_path / "agent_state.json"
+    state_path.write_text(json.dumps({
+        "schema_version": 1,
+        "research_goal": "stale cache",
+    }))
+    ledger = {"obligations": [{
+        "obligation_id": "RH-C0-root",
+        "statement": "RiemannHypothesis",
+        "parent_id": "",
+        "formal_status": "FORMALIZED",
+        "proposition_hash": canonical,
+    }]}
+    checkpoint = OrchestrationCheckpoint(
+        target_obligation_id="RH-C0-root",
+        proposition_hash="f" * 64,
+        research_contract_id="RC-root",
+        research_contract_hash="contract-hash",
+    )
+    before = asdict(checkpoint)
+    with pytest.raises(
+        ValueError,
+        match="CANONICAL_ROOT_PROPOSITION_MISMATCH",
+    ):
+        reconcile_canonical_root_binding(
+            checkpoint,
+            ledger,
+            state_path=state_path,
+        )
+    assert asdict(checkpoint) == before
+    assert json.loads(state_path.read_text())["research_goal"] == "stale cache"
+
+
 def test_live_status_atomic_transitions_and_permissions(tmp_path):
     path = tmp_path / "proof_live_status.json"
     status = AtomicLiveStatus(

tests/inference_engine/bridge/test_agent_gan_repl.py

@@ -3570,6 +3570,69 @@ def always_malformed(role, messages, expected_run_id):
     assert len(calls) == calls_before_restart
 
 
+def test_true_binding_mismatch_preserves_accepted_contract(tmp_path):
+    statement = "RiemannHypothesis"
+    root_hash = hashlib.sha256(statement.encode()).hexdigest()
+    ledger = ProofObligationLedger(
+        "rh",
+        [ProofObligation(
+            "RH-C0-root",
+            statement,
+            formal_status="FORMALIZED",
+            lean_signature_hash=root_hash,
+            proposition_hash=root_hash,
+        )],
+        version=96,
+    )
+    state_path = tmp_path / "orchestration.json"
+    checkpoint = OrchestrationCheckpoint(
+        state=ProofState.DECOMPOSER.value,
+        current_role="decomposer",
+        target_obligation_id="RH-C0-root",
+        candidate_sha256="candidate-hash",
+        parent_statement_sha256=root_hash,
+        parent_signature_sha256=root_hash,
+        root_goal_sha256=root_hash,
+        proposition_hash=root_hash,
+        research_contract_id="RC-root",
+        research_contract_hash="contract-hash",
+        ledger_id="rh",
+        ledger_version=96,
+    )
+    artifact = persist_validated_artifact(
+        state_path,
+        checkpoint,
+        role="research_contract",
+        payload={"schema_version": 1, "contract_id": "RC-root"},
+        dependencies=[],
+        source_run_id="host:contract",
+    )
+    runner, calls = _certificate_runner()
+    result = run_certified_decomposition(
+        ledger,
+        "RH-C0-root",
+        "Different proposition",
+        runner,
+        project_root=tmp_path,
+        orchestration_id="orch-mismatch",
+        signature_validator=_fake_signature_validator,
+        proof_validator=_fake_proof_validator,
+        checkpoint_path=state_path,
+        candidate_sha256="candidate-hash",
+    )
+    assert result.validation["blocked"] is True
+    assert result.validation["preserved_research_contract_id"] == "RC-root"
+    assert calls == []
+    preserved = load_orchestration_checkpoint(state_path)
+    assert preserved.research_contract_id == "RC-root"
+    assert preserved.research_contract_hash == "contract-hash"
+    assert preserved.validated_artifacts["research_contract"].sha256 == (
+        artifact.sha256
+    )
+    assert preserved.proof_state == ProofState.DECOMPOSER
+    assert preserved.adapter_status == "INTEGRATION_BLOCKED"
+
+
 @pytest.mark.skip(reason="legacy model-authored artifact execution is read-only")
 def test_resume_binding_mismatch_invalidates_cached_artifacts(tmp_path):
     state_path = tmp_path / "orchestration.json"