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

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.68"
+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.68 → 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.68",
+    "version": "2.3.71",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.68 → 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.68",
+  "dashboard_version": "2.3.71",
   "handoff_protocol": 1,
   "memory_format": 2,
   "minimum_codex_cli": "0.146.0",
   "inbox_protocol": 1,
-  "platform_version": "2.3.68",
+  "platform_version": "2.3.71",
   "report_format": 2,
-  "runner_version": "2.3.68",
+  "runner_version": "2.3.71",
   "status_model": 1,
-  "storage_schema": 44,
-  "watcher_version": "2.3.68"
+  "storage_schema": 45,
+  "watcher_version": "2.3.71"
 }

{engineering_platform-2.3.68 → engineering_platform-2.3.71}/src/engineering_platform/assets/dashboard.js

@@ -349,10 +349,22 @@ function phaseAwareRange(estimate) {
   if (estimate?.phase_aware !== true || samples < 2 || !Number.isFinite(lower) || !Number.isFinite(upper)) return null;
   return [Math.max(1, Math.round(lower / 60)), Math.max(1, Math.ceil(upper / 60))];
 }
+function exceededEstimateContext(durationEstimate, elapsedContext = "") {
+  const values = [elapsedContext, t("estimate.exceeded_context")];
+  if (hasHistoricalEstimate(durationEstimate)) values.push(historicalContext(durationEstimate, ""));
+  return values.filter(Boolean).join("\n");
+}
 function estimate(x, durationEstimate = {}) {
   const phase = x.current_phase || "";
   const phaseRange = phaseAwareRange(durationEstimate);
   if (["INITIALIZE", "EXECUTE_AGENT", "REPAIR_AGENT", "FINALIZATION_REPAIR_AGENT", "FINALIZE_AGENT", "REPOSITORY_CLEANUP"].includes(phase) && phaseRange) {
+    const remainingUpperSeconds = Number(durationEstimate?.remaining_upper_seconds);
+    if (Number.isFinite(remainingUpperSeconds) && remainingUpperSeconds <= 0) {
+      return {
+        summary: t("estimate.exceeded"),
+        context: exceededEstimateContext(durationEstimate),
+      };
+    }
     const [minimum, maximum] = phaseRange;
     return {
       summary: t("estimate.remaining", { minimum, maximum }),
@@ -375,6 +387,12 @@ function estimate(x, durationEstimate = {}) {
       remainingMinimum = Math.max(1, minimum - elapsed),
       remainingMaximum = Math.max(remainingMinimum, maximum - elapsed);
     const elapsedContext = t("estimate.elapsed", { elapsed, minutes: pluralMinutes(elapsed) });
+    if (maximum - elapsed <= 0) {
+      return {
+        summary: t("estimate.exceeded"),
+        context: exceededEstimateContext(durationEstimate, elapsedContext),
+      };
+    }
     return {
       summary: t("estimate.remaining", { minimum: remainingMinimum, maximum: remainingMaximum }),
       context: hasHistoricalEstimate(durationEstimate)

{engineering_platform-2.3.68 → engineering_platform-2.3.71}/src/engineering_platform/assets/dashboard_locales.mjs

@@ -251,6 +251,8 @@ export const DASHBOARD_MESSAGES = {
     "estimate.cleanup": "Cleanup in progress",
     "estimate.cleanup_context": "Remaining time depends on the local repository.",
     "estimate.elapsed": "{elapsed} {minutes} elapsed.\nBased on execution size, phase and elapsed time. No live Codex progress or token usage.",
+    "estimate.exceeded": "Estimate exceeded; remaining time uncertain",
+    "estimate.exceeded_context": "The prior range has elapsed; no reliable remaining time is available.",
     "estimate.finalizing": "Finalization in progress",
     "estimate.finalizing_context": "Remaining time is only reliable with live Codex progress.",
     "estimate.historical_context": "Refined with {count} comparable completed executions using the same reported runtime settings.",
@@ -899,6 +901,8 @@ export const DASHBOARD_MESSAGES = {
     "estimate.cleanup": "Opschoning in uitvoering",
     "estimate.cleanup_context": "De resterende tijd hangt af van de lokale repository.",
     "estimate.elapsed": "{elapsed} {minutes} verstreken.\nGebaseerd op opdrachtomvang, fase en verstreken tijd. Geen live Codex-voortgang of tokenverbruik.",
+    "estimate.exceeded": "Schatting overschreden; resterende tijd onzeker",
+    "estimate.exceeded_context": "De eerdere bandbreedte is verstreken; er is geen betrouwbare resterende tijd beschikbaar.",
     "estimate.finalizing": "Finalisatie in uitvoering",
     "estimate.finalizing_context": "De resterende tijd is pas betrouwbaar met live Codex-voortgang.",
     "estimate.historical_context": "Verfijnd met {count} vergelijkbare voltooide uitvoeringen met dezelfde gerapporteerde runtime-instellingen.",
@@ -1547,6 +1551,8 @@ export const DASHBOARD_MESSAGES = {
     "estimate.cleanup": "Bereinigung läuft",
     "estimate.cleanup_context": "Die Restzeit hängt vom lokalen Repository ab.",
     "estimate.elapsed": "{elapsed} {minutes} vergangen.\nBasierend auf Auftragsumfang, Phase und verstrichener Zeit. Kein Live-Codex-Fortschritt oder Tokenverbrauch.",
+    "estimate.exceeded": "Schätzung überschritten; Restzeit ungewiss",
+    "estimate.exceeded_context": "Die bisherige Zeitspanne ist verstrichen; es ist keine verlässliche Restzeit verfügbar.",
     "estimate.finalizing": "Finalisierung läuft",
     "estimate.finalizing_context": "Die Restzeit ist nur mit Live-Codex-Fortschritt zuverlässig.",
     "estimate.historical_context": "Verfeinert mit {count} vergleichbaren abgeschlossenen Ausführungen mit denselben gemeldeten Laufzeiteinstellungen.",
@@ -2129,6 +2135,8 @@ export const DASHBOARD_MESSAGES = {
     "estimate.cleanup": "Nettoyage en cours",
     "estimate.cleanup_context": "Le temps restant dépend du dépôt local.",
     "estimate.elapsed": "{elapsed} {minutes} écoulées.\nBasé sur la périmètre de l’exécution, la phase et le temps écoulé. Aucune progression Codex en direct ni consommation de jetons.",
+    "estimate.exceeded": "Estimation dépassée ; temps restant incertain",
+    "estimate.exceeded_context": "La plage précédente est écoulée ; aucun temps restant fiable n’est disponible.",
     "estimate.finalizing": "Finalisation en cours",
     "estimate.finalizing_context": "Le temps restant n’est fiable qu’avec la progression Codex en direct.",
     "estimate.historical_context": "Affiné à partir de {count} exécutions terminées comparables utilisant les mêmes paramètres d’exécution signalés.",
@@ -2711,6 +2719,8 @@ export const DASHBOARD_MESSAGES = {
     "estimate.cleanup": "Limpieza en curso",
     "estimate.cleanup_context": "El tiempo restante depende del repositorio local.",
     "estimate.elapsed": "{elapsed} {minutes} transcurridos.\nBasado en el alcance de la ejecución, la fase y el tiempo transcurrido. Sin progreso en directo de Codex ni consumo de tokens.",
+    "estimate.exceeded": "Estimación superada; tiempo restante incierto",
+    "estimate.exceeded_context": "El intervalo anterior ya transcurrió; no hay un tiempo restante fiable.",
     "estimate.finalizing": "Finalización en curso",
     "estimate.finalizing_context": "El tiempo restante solo es fiable con progreso de Codex en directo.",
     "estimate.historical_context": "Afinado con {count} ejecuciones completadas comparables que usan la misma configuración de ejecución informada.",

{engineering_platform-2.3.68 → 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.68 → 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.68 → 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:
@@ -1418,12 +1420,20 @@ class EngineeringRunner:
         """Return whether an agent supplied bounded evidence of a failed local check."""
         if not result.validation_evidence:
             return False
-        summaries = " ".join(
-            item.get("result", "").casefold()
-            for item in result.validation_evidence
-            if isinstance(item, dict)
-        )
-        return any(token in summaries for token in ("fail", "failed", "timeout", "timed out", "error"))
+        for item in result.validation_evidence:
+            if not isinstance(item, dict):
+                continue
+            summary = item.get("result", "").strip().casefold()
+            # Result summaries are dispositions followed by bounded detail.
+            # A passing disposition takes precedence over words such as
+            # "fail-closed" or "failure mode" in that descriptive detail.
+            if re.match(r"^(?:pass(?:ed)?|success(?:ful|fully)?|succeeded)\b", summary):
+                continue
+            if re.match(r"^(?:fail(?:ed|ure)?|error|timeout|timed\s+out)\b", summary):
+                return True
+            if re.search(r"\b(?:failed|failure|error|timeout|timed\s+out)\b", summary):
+                return True
+        return False
 
     @staticmethod
     def _is_external_agent_block(result: AgentResult) -> bool:
@@ -2723,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(
@@ -2890,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)
@@ -3273,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:
@@ -3389,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
@@ -3470,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(
@@ -3489,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:
-                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)
+            if state.transaction_kind == "RECONCILIATION" and result:
                 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)
@@ -3877,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)
@@ -3892,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)
@@ -3918,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.68 → 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.68 → 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.68 → 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.