engineering-platform 2.3.70__tar.gz → 2.3.71__tar.gz

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-platform
-Version: 2.3.70
+Version: 2.3.71
 Summary: Local-first Engineering Platform execution operations runtime
 Author: Peter van Tol
 License: MIT

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.70"
+version = "2.3.71"
 description = "Local-first Engineering Platform execution operations runtime"
 readme = "README.md"
 requires-python = ">=3.14,<3.15"
@@ -18,6 +18,7 @@ engineering-platform-host = "engineering_platform.__main__:main"
 engineering-platform-server = "engineering_platform.server:main"
 engineering-platform = "engineering_platform.submission_cli:main"
 engineering-project-agent = "engineering_platform.project_agent:main"
+engineering-reconciliation-adopt = "engineering_platform.reconciliation_adoption:main"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/ENGINEERING_PLATFORM_CONFIG.json

@@ -3,7 +3,7 @@
   "platform": {
     "id": "engineering-platform",
     "name": "Engineering Platform",
-    "version": "2.3.70",
+    "version": "2.3.71",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/ENGINEERING_PLATFORM_VERSION.json

@@ -1,15 +1,15 @@
 {
   "bootstrap_contract": "2026.12",
   "checkpoint_format": 1,
-  "dashboard_version": "2.3.70",
+  "dashboard_version": "2.3.71",
   "handoff_protocol": 1,
   "memory_format": 2,
   "minimum_codex_cli": "0.146.0",
   "inbox_protocol": 1,
-  "platform_version": "2.3.70",
+  "platform_version": "2.3.71",
   "report_format": 2,
-  "runner_version": "2.3.70",
+  "runner_version": "2.3.71",
   "status_model": 1,
-  "storage_schema": 44,
-  "watcher_version": "2.3.70"
+  "storage_schema": 45,
+  "watcher_version": "2.3.71"
 }

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/contracts/projection.py

@@ -306,6 +306,7 @@ def get_run_context(root: Path, run_id: str) -> dict[str, object]:
     snapshot_checks = qualification_source.get("pr_checks", {}) if qualification_source else {}
     implementation = snapshot_checks.get("IMPLEMENTATION", {}) if qualification_source and isinstance(snapshot_checks, dict) else checks.get("IMPLEMENTATION", {})
     finalization = snapshot_checks.get("FINALIZATION", {}) if qualification_source and isinstance(snapshot_checks, dict) else checks.get("FINALIZATION", {})
+    reconciliation = snapshot_checks.get("RECONCILIATION", {}) if qualification_source and isinstance(snapshot_checks, dict) else checks.get("RECONCILIATION", {})
     objective = _safe_objective(submission[3] if submission else {})
     validation_only = action_intent == "VALIDATION_ONLY"
     persisted_required_validation = qualification_source.get("validation_profile", UNAVAILABLE) if qualification_source else qualification_validation or UNAVAILABLE
@@ -337,8 +338,14 @@ def get_run_context(root: Path, run_id: str) -> dict[str, object]:
                      "finalization_pr": "NOT_REQUIRED" if validation_only else _value(qualification_source.get("finalization_pr") if qualification_source else checkpoint.get("finalization_pull_request") or finalization.get("pr_number")), "finalization_pr_current_state": "NOT_REQUIRED" if validation_only else _value(finalization.get("pr_state")),
                      "finalization_merge_state": _value(finalization.get("merge_state")), "finalization_merge_commit": _value(finalization.get("merge_commit") if qualification_source else checkpoint.get("finalization_merge_commit") or finalization.get("merge_commit")),
                      "finalization_required_checks_state": _value(finalization.get("required_checks_state")), "finalization_merge_gate": "EXPECTED_OPERATOR_GATE" if phase == "WAIT_FOR_FINALIZATION_MERGE" else UNAVAILABLE,
+                     "reconciliation_pr": "NOT_REQUIRED" if validation_only else _value(qualification_source.get("reconciliation_pr") if qualification_source else checkpoint.get("reconciliation_pull_request") or reconciliation.get("pr_number")),
+                     "reconciliation_pr_current_state": "NOT_REQUIRED" if validation_only else _value(reconciliation.get("pr_state")),
+                     "reconciliation_merge_state": _value(reconciliation.get("merge_state")),
+                     "reconciliation_required_checks_state": _value(reconciliation.get("required_checks_state")),
+                     "reconciliation_merge_gate": "EXPECTED_OPERATOR_GATE" if phase == "WAIT_FOR_RECONCILIATION_MERGE" else UNAVAILABLE,
                      "implementation_delivery": _value(qualification_source.get("implementation_delivery")),
                      "finalization_delivery": _value(qualification_source.get("finalization_delivery")),
+                     "reconciliation_delivery": _value(qualification_source.get("reconciliation_delivery")),
                      "run_delivery_commit": _value(checkpoint.get("implementation_head_sha") or checkpoint.get("last_verified_sha")), "current_repository_head": _value(checkpoint.get("last_verified_sha")), "delivery_commit_head_relationship": UNAVAILABLE},
         "validation": {"engineering_platform_qualification": UNAVAILABLE, "controls": validation_controls,
                        "required_validation": persisted_required_validation,

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/execution_finalization.py

@@ -33,7 +33,10 @@ class FinalizationCoordinator:
         if not callable(operation):
             return save_terminal(cleanup, "BLOCKED", "cleanup_unavailable", "Cleanup client is unavailable; resume with repository cleanup evidence.")
         try:
-            result = operation(root, (cleanup.implementation_branch, cleanup.finalization_branch))
+            branches = (cleanup.implementation_branch, cleanup.finalization_branch)
+            if cleanup.transaction_kind == "RECONCILIATION":
+                branches += (cleanup.branch,)
+            result = operation(root, branches)
         except RunnerError as error:
             return save_terminal(cleanup, "BLOCKED", "repository_cleanup_required", str(error))
         return save_terminal(

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/execution_host.py

@@ -82,7 +82,7 @@ from .reviewer_evidence import ReviewerEvidence
 from .investigation_ledger import InvocationInvestigationLedger
 from .execution_errors import CodexHandoffTimeout, CodexInvocationError, RunnerError
 from .execution_errors import ProviderReadinessBlocked
-from .execution_timeout_policy import FINALIZATION, REPAIR, agent_timeout
+from .execution_timeout_policy import END_RECONCILIATION, FINALIZATION, REPAIR, agent_timeout
 from .provider_readiness import failures as provider_readiness_failures
 from .execution_repository import GitHubClient as ProviderGitHubClient, RepositoryClient as ProviderRepositoryClient
 from .execution_repository import GhCliClient as ProviderGhCliClient, SubprocessRepositoryClient as ProviderRepositoryClientImpl
@@ -125,6 +125,7 @@ from .component_logging import component_logger, record_technical_diagnostic, sh
 
 # Compatibility exports for integrations that already import these names.
 FINALIZATION_PR_HANDOFF_MAX_SECONDS = FINALIZATION.seconds
+RECONCILIATION_PR_HANDOFF_MAX_SECONDS = END_RECONCILIATION.seconds
 REPAIR_AGENT_MAX_SECONDS = REPAIR.seconds
 
 # A repair remains scoped to its original PR, but it must also have a finite
@@ -305,11 +306,12 @@ def assemble_prompt(
     )
     authority = (
         """This is the sole automatic post-Finalization reconciliation. You may only update
-the four canonical rolling records, commit them directly to the already synchronized `main`,
-and push that one commit. Do not create a branch or pull request. Do not change runtime code,
-authority, lifecycle, retry, validation, provider, Forge, queue, or delivery semantics. Return
-`COMPLETE`, `repository_reconciled`, and the pushed main commit SHA only after verifying a clean
-workspace and that `main` contains that exact commit."""
+the four canonical rolling records on the exact checkpointed reconciliation branch, commit and
+push that branch, and create one draft pull request to `main`. Do not change runtime code,
+authority, lifecycle, retry, validation, provider, Forge, queue, or delivery semantics. Do not
+merge the pull request or push directly to `main`. Return `COMPLETE`, `repository_reconciled`,
+the branch, pull-request number, and exact candidate commit SHA only after verifying a clean
+workspace."""
         if state and state.transaction_kind == "RECONCILIATION"
         else
         """The runner holds explicit owner authorization for this exact bounded transaction. You may create, commit and push one bounded branch and draft pull request, or repair that same pull request. The runner may mark that pull request ready for review, but only the human operator may merge it. Do not merge, release, deploy, tag, publish, upload, change repository settings, bypass protection, or expand the objective."""
@@ -1090,7 +1092,7 @@ class EngineeringRunner:
     def _managed_pr_check(self, state: TransactionState, pr: PullRequestEvidence) -> None:
         """Persist current GitHub required-check evidence separately from historical waits."""
         role = state.transaction_kind
-        if role not in {"IMPLEMENTATION", "FINALIZATION"}:
+        if role not in {"IMPLEMENTATION", "FINALIZATION", "RECONCILIATION"}:
             return
         check_state = "PASS" if pr.checks_terminal and pr.checks_passed else "FAIL" if pr.checks_terminal else "WAITING"
         try:
@@ -2731,6 +2733,8 @@ First implementation pull-request publication gate:
             return self._advance_after_repair_agent_result(state, result)
         if lifecycle_phase == "FINALIZE_AGENT":
             return self._advance_after_finalization_agent_result(state, result)
+        if lifecycle_phase == "RECONCILE_AGENT":
+            return self._advance_after_reconciliation_agent_result(state, result)
         return self._save_terminal(state, "BLOCKED", "recovered_provider_phase_invalid", "Recovered provider result has an unsupported lifecycle phase.")
 
     def run(
@@ -2898,7 +2902,7 @@ First implementation pull-request publication gate:
         recovered_resume = (
             isinstance(recovery_snapshot, dict)
             and recovery_snapshot.get("state") == "RECOVERED"
-            and recovery_snapshot.get("lifecycle_phase") in {"EXECUTE_AGENT", "QUALITY_CONTROL_AGENT", "REPAIR_AGENT", "FINALIZE_AGENT"}
+            and recovery_snapshot.get("lifecycle_phase") in {"EXECUTE_AGENT", "QUALITY_CONTROL_AGENT", "REPAIR_AGENT", "FINALIZE_AGENT", "RECONCILE_AGENT"}
         )
         try:
             persisted_submission = load_submission_for_run(self.root, state.run_id, central_database=self.store.central_database)
@@ -3281,6 +3285,8 @@ First implementation pull-request publication gate:
             state = self._record_agent_execution_time(state)
             self.console_detail = error.console_detail
             return self._terminalize_provider_invocation_error(state, error)
+        if state.transaction_kind == "RECONCILIATION":
+            return self._advance_after_reconciliation_agent_result(state, result)
         return self._advance_after_primary_agent_result(state, result, evidence)
 
     def _active_genesis_transaction(self, target: Path, run_id: str) -> str | None:
@@ -3397,10 +3403,7 @@ First implementation pull-request publication gate:
                 next_action="create_finalization",
             )
         if state.transaction_kind == "RECONCILIATION" and not state.reconciliation_pull_request:
-            return replace(
-                state, phase="RECONCILE_AGENT", last_verified_sha=evidence.head_sha,
-                next_action="create_reconciliation",
-            )
+            return self._recover_reconciliation_pull_request(state, evidence)
         if (
             state.transaction_kind == "FINALIZATION"
             and state.finalization_merge_commit
@@ -3478,6 +3481,54 @@ First implementation pull-request publication gate:
         write_live_status(self.root, recovered, recovered.next_action)
         return self._poll(recovered)
 
+    def _recover_reconciliation_pull_request(
+        self, state: TransactionState, evidence: RepositoryEvidence,
+    ) -> TransactionState:
+        """Recover only the PR bound to the durable reconciliation branch."""
+        if state.reconciliation_pull_request:
+            return replace(
+                state, pull_request=state.reconciliation_pull_request,
+                phase="WAIT_FOR_TERMINAL_EVIDENCE", next_action="poll_required_checks",
+            )
+        if (
+            not state.branch
+            or state.branch == "main"
+            or not state.finalization_merge_commit
+            or evidence.branch not in {"main", state.branch}
+            or not evidence.clean
+            or not self.repository.main_contains(self.root, state.finalization_merge_commit)
+        ):
+            return self._save_terminal(
+                state, "BLOCKED", "reconciliation_recovery_evidence_required",
+                "Reconciliation recovery requires its checkpointed branch and a verified Finalization merge.",
+            )
+        candidate = self.github.pull_request_for_head_branch(state.branch)
+        if candidate is None:
+            return self._save_terminal(
+                state, "BLOCKED", "reconciliation_recovery_evidence_required",
+                "No reconciliation pull request matches the checkpointed branch; no replacement was created.",
+            )
+        if (
+            candidate.head_branch != state.branch
+            or candidate.base_branch != "main"
+            or candidate.state not in {"OPEN", "MERGED"}
+        ):
+            return self._save_terminal(
+                state, "BLOCKED", "reconciliation_recovery_evidence_invalid",
+                "Reconciliation pull request evidence does not match the checkpointed branch and main base.",
+            )
+        recovered = replace(
+            state, pull_request=candidate.number,
+            reconciliation_pull_request=candidate.number,
+            phase="WAIT_FOR_TERMINAL_EVIDENCE", next_action="poll_required_checks",
+            last_verified_sha=evidence.head_sha,
+            latest_repository_evidence=_repository_summary(evidence),
+            latest_github_evidence=_pull_request_summary(candidate),
+        )
+        self.store.save(recovered)
+        write_live_status(self.root, recovered, recovered.next_action)
+        return self._poll(recovered)
+
     def _poll(self, state: TransactionState, result: AgentResult | None = None) -> TransactionState:
         if state.pull_request:
             state = self._provider_readiness_gate(
@@ -3497,32 +3548,10 @@ First implementation pull-request publication gate:
                 "Agent result referenced a pull request without a transaction branch; the current main branch cannot be reused as execution evidence.",
             )
         if not state.pull_request:
-            if state.transaction_kind == "RECONCILIATION" and result and result.pull_request:
+            if state.transaction_kind == "RECONCILIATION" and result:
                 return self._save_terminal(
-                    state, "BLOCKED", "reconciliation_pull_request_forbidden",
-                    "Automatic reconciliation must commit directly to main and must not create a pull request.",
-                )
-            if state.transaction_kind == "RECONCILIATION" and result and result.terminal_state == "COMPLETE":
-                evidence = self.repository.inspect(self.root)
-                if (
-                    result.terminal_condition == "repository_reconciled"
-                    and result.commit_sha
-                    and evidence.clean
-                    and evidence.branch == "main"
-                    and evidence.head_sha == result.commit_sha
-                    and evidence.main_contains_head
-                ):
-                    reconciled = replace(state, last_verified_sha=result.commit_sha)
-                    reconciled = self._append_verified_commit_evidence(
-                        reconciled,
-                        phase="RECONCILE_AGENT",
-                        commit_sha=result.commit_sha,
-                        description="end_reconciliation_commit_verified",
-                    )
-                    return self._cleanup(reconciled)
-                return self._save_terminal(
-                    state, "BLOCKED", "automatic_reconciliation_evidence_required",
-                    "Automatic reconciliation requires a clean main checkout containing its reported commit.",
+                    state, "BLOCKED", "reconciliation_pr_required",
+                    "Automatic reconciliation requires its checkpointed pull request before cleanup.",
                 )
             if result and result.terminal_state == "COMPLETE":
                 evidence = self.repository.inspect(self.root)
@@ -3885,12 +3914,7 @@ First implementation pull-request publication gate:
         return self._poll(finalization, result)
 
     def _start_automatic_reconciliation(self, state: TransactionState) -> TransactionState:
-        """Apply the bounded rolling-record update after Finalization merges.
-
-        This is deliberately a direct, post-merge `main` commit: it has no PR,
-        review, approval, or operator merge boundary. Its scope is enforced by
-        the supplied reconciliation prompt and the exact commit evidence below.
-        """
+        """Apply the bounded rolling-record update through a protected PR."""
         synchronize = getattr(self.repository, "synchronize_main", None)
         if callable(synchronize):
             synchronize(self.root)
@@ -3900,22 +3924,37 @@ First implementation pull-request publication gate:
                 state,
                 "End reconciliation is waiting for a clean, synchronized main checkout.",
             )
+        expected_branch = (
+            state.branch
+            if state.transaction_kind == "RECONCILIATION" and state.branch != "main"
+            else None
+        ) or f"codex/reconcile-{state.run_id}"
         reconciliation = replace(
             state, phase="RECONCILE_AGENT", transaction_kind="RECONCILIATION",
-            branch=None, pull_request=None, reconciliation_pull_request=None,
-            next_action="reconcile_rolling_records_on_main", waiting_for_merge_since=None,
+            branch=expected_branch, pull_request=None, reconciliation_pull_request=None,
+            next_action="create_reconciliation_pull_request", waiting_for_merge_since=None,
             latest_repository_evidence=_repository_summary(evidence),
         )
         self._managed_action(reconciliation, "AUTOMATIC_RECONCILIATION")
         self.store.save(reconciliation)
         write_live_status(self.root, reconciliation, reconciliation.next_action)
+        reconciliation_span = self._start_phase(state.run_id, "RECONCILIATION")
+        handoff_started = time.monotonic()
+        set_handoff_deadline = getattr(self.agent, "set_handoff_deadline_callback", None)
+        if callable(set_handoff_deadline):
+            set_handoff_deadline(
+                lambda: time.monotonic() - handoff_started
+                >= RECONCILIATION_PR_HANDOFF_MAX_SECONDS
+            )
         try:
             result = self._invoke_agent_with_timing(
                 reconciliation,
                 assemble_prompt(
                     Path(reconciliation.prompt_path), reconciliation,
                     managed_target=self.root if reconciliation.execution_mode == "MANAGED" else None,
-                ) + "\n\nReconcile only the four canonical rolling current-state records after the verified Finalization merge. Preserve immutable Prompt History.",
+                )
+                + "\n\nReconcile only the four canonical rolling current-state records after the verified Finalization merge. "
+                f"Preserve immutable Prompt History and create one draft pull request on exactly `{expected_branch}`.",
             )
             reconciliation = self._record_agent_execution_time(reconciliation)
             reconciliation = self._record_validation_evidence(reconciliation, result)
@@ -3926,12 +3965,63 @@ First implementation pull-request publication gate:
                 description="end_reconciliation_commit_verified",
             )
             self._persist_agent_usage(reconciliation.run_id)
+        except CodexHandoffTimeout:
+            complete_phase(self.root, reconciliation_span, outcome="FAILED")
+            reconciliation = self._record_agent_execution_time(reconciliation)
+            return self._recover_reconciliation_pull_request(
+                reconciliation, self.repository.inspect(self.root)
+            )
         except ProviderReadinessBlocked as blocked:
+            complete_phase(self.root, reconciliation_span, outcome="BLOCKED")
             return blocked.state
         except CodexInvocationError as error:
+            complete_phase(
+                self.root, reconciliation_span,
+                outcome="INTERRUPTED" if error.provider_turn_interrupted else "FAILED",
+            )
             reconciliation = self._record_agent_execution_time(reconciliation)
             self.console_detail = error.console_detail
             return self._terminalize_provider_invocation_error(reconciliation, error)
+        finally:
+            if callable(set_handoff_deadline):
+                set_handoff_deadline(None)
+        complete_phase(self.root, reconciliation_span)
+        return self._advance_after_reconciliation_agent_result(reconciliation, result)
+
+    def _advance_after_reconciliation_agent_result(
+        self, reconciliation: TransactionState, result: AgentResult,
+    ) -> TransactionState:
+        """Bind a live or recovered reconciliation result to its one PR."""
+        if result.terminal_state in {"BLOCKED", "FAILED"} or not result.pull_request:
+            return self._save_terminal(
+                reconciliation,
+                result.terminal_state
+                if result.terminal_state in {"BLOCKED", "FAILED"}
+                else "BLOCKED",
+                "reconciliation_pr_required",
+                result.diagnostic or "Reconciliation pull request was not created.",
+            )
+        expected_branch = reconciliation.branch
+        if not expected_branch or expected_branch == "main" or result.branch != expected_branch:
+            return self._save_terminal(
+                reconciliation, "BLOCKED", "reconciliation_branch_mismatch",
+                "Reconciliation returned a pull request outside the durable reconciliation branch.",
+            )
+        reconciliation = replace(
+            reconciliation,
+            phase="WAIT_FOR_TERMINAL_EVIDENCE",
+            pull_request=result.pull_request,
+            reconciliation_pull_request=result.pull_request,
+            terminal_condition="repository_reconciled",
+            next_action="poll_required_checks",
+        )
+        self.store.save(reconciliation)
+        write_live_status(self.root, reconciliation, reconciliation.next_action)
+        evidence = self.github.pull_request(result.pull_request)
+        if evidence.state == "MERGED":
+            return self._poll(reconciliation, result)
+        self.github.normalize_markdown_body(result.pull_request)
+        self.github.ready(result.pull_request)
         return self._poll(reconciliation, result)
 
     def _save_terminal(

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/execution_lifecycle.py

@@ -19,12 +19,12 @@ TERMINAL = frozenset({"COMPLETE", "BLOCKED", "FAILED"})
 _MANAGED_PATH = (
     "START", "INITIALIZE", "CAPABILITY_REVIEW", "EXECUTE_AGENT", "LOCAL_REPOSITORY_VALIDATION", "QUALITY_CONTROL_AGENT", "REPAIR_AGENT",
     "WAIT_FOR_OPERATOR_MERGE", "FINALIZE_AGENT", "WAIT_FOR_FINALIZATION_MERGE",
-    "RECONCILE_AGENT", "REPOSITORY_CLEANUP", "TERMINAL",
+    "RECONCILE_AGENT", "WAIT_FOR_RECONCILIATION_MERGE", "REPOSITORY_CLEANUP", "TERMINAL",
 )
 _FINALIZATION_REPAIR_PATH = (
     "START", "INITIALIZE", "CAPABILITY_REVIEW", "EXECUTE_AGENT", "QUALITY_CONTROL_AGENT", "REPAIR_AGENT",
     "WAIT_FOR_OPERATOR_MERGE", "FINALIZE_AGENT", "FINALIZATION_REPAIR_AGENT", "WAIT_FOR_FINALIZATION_MERGE",
-    "RECONCILE_AGENT", "REPOSITORY_CLEANUP", "TERMINAL",
+    "RECONCILE_AGENT", "WAIT_FOR_RECONCILIATION_MERGE", "REPOSITORY_CLEANUP", "TERMINAL",
 )
 # Genesis has no pull-request merge boundary.  This is presentation of the
 # existing mode contract, not a new execution sequence.
@@ -52,6 +52,7 @@ _STEP_PHASES = {
     "WAIT_FOR_OPERATOR_MERGE": frozenset({"PR_OR_MERGE", "EXTERNAL_CI_WAIT"}),
     "FINALIZE_AGENT": frozenset({"REPOSITORY_FINALIZATION", "FINALIZATION"}),
     "RECONCILE_AGENT": frozenset({"RECONCILIATION", "REPORT_GENERATION", "EVIDENCE_PERSISTENCE"}),
+    "WAIT_FOR_RECONCILIATION_MERGE": frozenset({"PR_OR_MERGE", "EXTERNAL_CI_WAIT"}),
     "REPOSITORY_CLEANUP": frozenset({"REPOSITORY_CLEANUP"}),
     "TERMINAL": frozenset({"TOTAL_EXECUTION"}),
 }

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/execution_reporting.py

@@ -397,6 +397,7 @@ def _commit_strategy(state: TransactionState, bundle: TerminalEvidenceBundle) ->
         f"- Implementation merge: `{state.implementation_merge_commit or 'not recorded'}`",
         f"- Finalization PR: `{state.finalization_pull_request or 'not recorded'}`",
         f"- Finalization merge: `{state.finalization_merge_commit or 'not recorded'}`",
+        f"- Reconciliation PR: `{state.reconciliation_pull_request or 'not recorded'}`",
     )
 
 
@@ -1080,6 +1081,7 @@ def _managed_autonomy_projection(root: Path, state: TransactionState, bundle: Te
     snapshot = managed_autonomy_snapshot(
         root, run_id=state.run_id, execution_outcome=state.phase,
         implementation_pr=state.implementation_pull_request, finalization_pr=state.finalization_pull_request,
+        reconciliation_pr=state.reconciliation_pull_request,
         repository_state="MERGED_RECONCILED" if state.phase == "COMPLETE" and (state.finalization_merge_commit or state.action_intent == "VALIDATION_ONLY") else "UNAVAILABLE",
         workspace_state="WORKSPACE_READY" if state.phase == "COMPLETE" and bundle.worktree_state == "clean" else "UNAVAILABLE",
         main_origin_sync="YES" if bundle.target_branch == "main" else "UNAVAILABLE",
@@ -1503,6 +1505,7 @@ def generate_terminal_report(
             "## Pull Requests",
             f"- Implementation: branch `{state.implementation_branch}`, PR `{state.implementation_pull_request}`, merge `{state.implementation_merge_commit}`",
             f"- Finalization: branch `{state.finalization_branch}`, PR `{state.finalization_pull_request}`, merge `{state.finalization_merge_commit}`",
+            f"- Reconciliation: branch `{state.branch if state.transaction_kind == 'RECONCILIATION' else None}`, PR `{state.reconciliation_pull_request}`",
             "",
             *_retry_relationship(state),
             "## Initial Repository Assessment",
@@ -1600,7 +1603,7 @@ def generate_terminal_report(
             "## Metrics",
             f"- Codex CLI execution time: {state.agent_execution_seconds if state.agent_execution_seconds is not None else 'not measured'} seconds",
             f"- Repair iterations: {state.repair_iterations}",
-            f"- PRs created: {sum(value is not None for value in (state.implementation_pull_request, state.finalization_pull_request))}",
+            f"- PRs created: {sum(value is not None for value in (state.implementation_pull_request, state.finalization_pull_request, state.reconciliation_pull_request))}",
             f"- Merges performed: {sum(value is not None for value in (state.implementation_merge_commit, state.finalization_merge_commit))}",
             "",
         )

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/execution_repository.py

@@ -44,7 +44,9 @@ class GitHubClient(Protocol):
     def ready(self, number: int) -> None: ...
     def normalize_markdown_body(self, number: int) -> bool: ...
     def merge(self, number: int) -> None: ...
-    def create_or_recover_pull_request(self, branch: str, base: str, title: str, body: str) -> PullRequestEvidence: ...
+    def create_or_recover_pull_request(
+        self, branch: str, base: str, title: str, body: str, *, draft: bool = False,
+    ) -> PullRequestEvidence: ...
     def qualification_for_exact_head(self, number: int, head_sha: str) -> dict[str, object]: ...
     def version_preparation_writer(self) -> dict[str, object]: ...
 
@@ -250,7 +252,9 @@ class GhCliClient:
             raise RunnerError("Finalization recovery found more than one pull request for its checkpointed branch.")
         return self.pull_request(numbers[0])
 
-    def create_or_recover_pull_request(self, branch: str, base: str, title: str, body: str) -> PullRequestEvidence:
+    def create_or_recover_pull_request(
+        self, branch: str, base: str, title: str, body: str, *, draft: bool = False,
+    ) -> PullRequestEvidence:
         """Create one bounded PR or recover the sole existing branch identity."""
         existing = self.pull_request_for_head_branch(branch)
         if existing is not None:
@@ -258,7 +262,13 @@ class GhCliClient:
                 raise RunnerError("Version preparation branch already has a pull request for another base.")
             return existing
         try:
-            raw = self._github("pr", "create", "--head", branch, "--base", base, "--title", title, "--body", body)
+            arguments = [
+                "pr", "create", "--head", branch, "--base", base,
+                "--title", title, "--body", body,
+            ]
+            if draft:
+                arguments.append("--draft")
+            raw = self._github(*arguments)
         except RuntimeError as error:
             # A successful create may lose its acknowledgement.  Only recover
             # the deterministic branch identity; never create a second PR.

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/managed_autonomy.py

@@ -30,13 +30,17 @@ AUTHORITIES = frozenset(
         "UNKNOWN_AUTHORITY",
     }
 )
-GATE_TYPES = frozenset({"IMPLEMENTATION_MERGE_APPROVAL", "FINALIZATION_MERGE_APPROVAL"})
+GATE_TYPES = frozenset({
+    "IMPLEMENTATION_MERGE_APPROVAL",
+    "FINALIZATION_MERGE_APPROVAL",
+    "RECONCILIATION_MERGE_APPROVAL",
+})
 GATE_STATUSES = frozenset({"NOT_REQUIRED", "WAITING", "SATISFIED", "UNAVAILABLE"})
 VALIDATION_STATES = frozenset(
     {"PASS", "FAIL", "NOT_EXECUTED", "NOT_APPLICABLE", "UNAVAILABLE", "WAITING"}
 )
 PR_CHECK_STATES = frozenset({"PASS", "FAIL", "WAITING", "UNAVAILABLE"})
-PR_ROLES = frozenset({"IMPLEMENTATION", "FINALIZATION"})
+PR_ROLES = frozenset({"IMPLEMENTATION", "FINALIZATION", "RECONCILIATION"})
 
 
 def _connection(root: Path, central_database: Path | None) -> sqlite3.Connection:
@@ -256,6 +260,7 @@ def terminal_snapshot(
     worktree_state: str,
     active_blocker: str,
     recovery_required: str,
+    reconciliation_pr: int | None = None,
     retry_parent: str | None = None,
     resume_parent: str | None = None,
     submission_id: str | None = None,
@@ -358,6 +363,7 @@ def terminal_snapshot(
         "submission_id": submission_id or "UNAVAILABLE",
         "implementation_pr": implementation_pr,
         "finalization_pr": finalization_pr,
+        "reconciliation_pr": reconciliation_pr,
         "gates": [{"gate_type": row[0], "status": row[1], "related_pr": row[2]} for row in gates],
         "actions": [{"action": row[0], "authority": row[1]} for row in actions],
         "validation_current": validation,
@@ -385,7 +391,10 @@ def terminal_snapshot(
         ),
         "observed_at": _now(),
     }
-    for role, pr_number in (("IMPLEMENTATION", implementation_pr), ("FINALIZATION", finalization_pr)):
+    deliveries = [("IMPLEMENTATION", implementation_pr), ("FINALIZATION", finalization_pr)]
+    if reconciliation_pr is not None:
+        deliveries.append(("RECONCILIATION", reconciliation_pr))
+    for role, pr_number in deliveries:
         check = pr_checks.get(role, {})
         snapshot[f"{role.lower()}_delivery"] = (
             "COMPLETE"
@@ -474,6 +483,11 @@ def evaluate(snapshot: dict[str, object]) -> tuple[str, list[str]]:
             reasons.append("IMPLEMENTATION_MERGE_GATE_UNPROVEN")
         if gate.get("FINALIZATION_MERGE_APPROVAL") != "SATISFIED":
             reasons.append("FINALIZATION_MERGE_GATE_UNPROVEN")
+        if snapshot.get("reconciliation_pr") is not None:
+            if snapshot.get("reconciliation_delivery") != "COMPLETE":
+                reasons.append("RECONCILIATION_DELIVERY_UNPROVEN")
+            if gate.get("RECONCILIATION_MERGE_APPROVAL") != "SATISFIED":
+                reasons.append("RECONCILIATION_MERGE_GATE_UNPROVEN")
     autonomous = {
         row.get("action")
         for row in snapshot.get("actions", [])
@@ -498,7 +512,10 @@ def evaluate(snapshot: dict[str, object]) -> tuple[str, list[str]]:
         reasons.append("EVIDENCE_CONFLICT")
     if snapshot.get("pr_check_projection_conflict"):
         reasons.append("EVIDENCE_CONFLICT")
-    for role in (() if validation_only else ("IMPLEMENTATION", "FINALIZATION")):
+    roles = ["IMPLEMENTATION", "FINALIZATION"]
+    if snapshot.get("reconciliation_pr") is not None:
+        roles.append("RECONCILIATION")
+    for role in (() if validation_only else roles):
         if snapshot.get(f"{role.lower()}_pr") is not None:
             check = snapshot.get("pr_checks", {}).get(role, {})
             if check.get("required_checks_state") != "PASS":

{engineering_platform-2.3.70 → engineering_platform-2.3.71}/src/engineering_platform/platform_version.py

@@ -12,7 +12,7 @@ from .storage import ENGINEERING_STORAGE_SCHEMA_VERSION
 
 SEMVER = re.compile(r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$")
 CONTRACT = re.compile(r"^(\d{4})\.(0[1-9]|1[0-2])$")
-CURRENT_PLATFORM_VERSION = "2.3.70"
+CURRENT_PLATFORM_VERSION = "2.3.71"
 MANIFEST_FIELDS = frozenset(
     {
         "platform_version",