engineering-platform 2.3.73__tar.gz → 2.3.75__tar.gz

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/PKG-INFO

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

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.73"
+version = "2.3.75"
 description = "Local-first Engineering Platform execution operations runtime"
 readme = "README.md"
 requires-python = ">=3.14,<3.15"

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/ENGINEERING_PLATFORM_CONFIG.json

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

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/ENGINEERING_PLATFORM_VERSION.json

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

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/execution_host.py

@@ -3663,6 +3663,8 @@ First implementation pull-request publication gate:
                     action = {"IMPLEMENTATION": "IMPLEMENTATION_MERGE", "FINALIZATION": "FINALIZATION_MERGE", "RECONCILIATION": "RECONCILIATION_MERGE"}[state.transaction_kind]
                     self._managed_action(state, action, "EXPECTED_OPERATOR_GATE", actor="operator", evidence_ref="github_merge")
                     state = self._record_merged_evidence(state, pr, evidence)
+                    if state.terminal:
+                        return state
                     if state.owner_authorized and state.transaction_kind == "IMPLEMENTATION":
                         return self._start_finalization(state, pr.number)
                     if state.owner_authorized and state.transaction_kind == "FINALIZATION":
@@ -4145,6 +4147,26 @@ First implementation pull-request publication gate:
     def _record_merged_evidence(
         self, state: TransactionState, pr: PullRequestEvidence, evidence: RepositoryEvidence
     ) -> TransactionState:
+        expected_head = (
+            (state.implementation_head_sha or state.last_verified_sha)
+            if state.transaction_kind == "IMPLEMENTATION"
+            else (state.finalization_head_sha or state.last_verified_sha)
+            if state.transaction_kind == "FINALIZATION"
+            else None
+        )
+        if (
+            state.transaction_kind in {"IMPLEMENTATION", "FINALIZATION"}
+            and isinstance(expected_head, str)
+            and isinstance(pr.head_sha, str)
+            and pr.head_sha != expected_head
+        ):
+            return self._save_terminal(
+                state,
+                "BLOCKED",
+                "merged_pull_request_candidate_mismatch",
+                "Merged pull-request evidence does not match the exact phase candidate.",
+            )
+        phase_head = pr.head_sha or expected_head
         common = {
             "last_verified_sha": evidence.head_sha,
             "latest_repository_evidence": _repository_summary(evidence),
@@ -4155,7 +4177,7 @@ First implementation pull-request publication gate:
                 state,
                 implementation_branch=state.branch,
                 implementation_pull_request=pr.number,
-                implementation_head_sha=state.last_verified_sha,
+                implementation_head_sha=phase_head,
                 implementation_merge_commit=pr.merge_commit,
                 **common,
             )
@@ -4168,7 +4190,7 @@ First implementation pull-request publication gate:
                 state,
                 finalization_branch=state.branch or state.finalization_branch,
                 finalization_pull_request=pr.number,
-                finalization_head_sha=state.last_verified_sha,
+                finalization_head_sha=phase_head,
                 finalization_merge_commit=pr.merge_commit,
                 **common,
             )

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/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.73"
+CURRENT_PLATFORM_VERSION = "2.3.75"
 MANIFEST_FIELDS = frozenset(
     {
         "platform_version",

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/server.py

@@ -124,7 +124,7 @@ SERVER_CONFIGURATION_VERSION = 3
 # bootstrap is deliberately separate from the retired predecessor migration
 # machinery: it creates a clean installation only and never accepts a source
 # database path.
-SERVER_STORE_SCHEMA_VERSION = 66
+SERVER_STORE_SCHEMA_VERSION = 67
 SERVER_ENVIRONMENT_DATA_ROOT = "EP_SERVER_DATA_ROOT"
 FILE_INBOX_DIRECTORY = "file-inbox"
 HTTP_JSON_OPENAPI_PATH = "/v1/openapi.json"
@@ -591,6 +591,7 @@ SERVER_REQUIRED_TABLES = frozenset(
         "ep_forge_planning_context_envelopes",
         "ep_execution_host_evidence",
         "ep_technical_diagnostics",
+        "ep_terminal_evidence_reconciliation_operations",
     }
 )
 SERVER_REQUIRED_INDEXES = frozenset(
@@ -614,6 +615,7 @@ SERVER_REQUIRED_INDEXES = frozenset(
         "ep_forge_action_context_envelopes_project_lookup",
         "ep_forge_planning_context_envelopes_project_lookup",
         "ep_technical_diagnostics_created_lookup",
+        "execution_artifact_records_active_terminal_run",
     }
 )
 SERVER_REQUIRED_VIEWS = frozenset({"execution_submission_run_links"})
@@ -813,6 +815,7 @@ def _install_current_schema(connection: sqlite3.Connection, identity: RuntimeIde
     _install_execution_host_evidence_schema(connection)
     _install_technical_diagnostics_schema(connection)
     owner_credential_recovery.install_schema(connection)
+    submission_service.install_terminal_evidence_reconciliation_schema(connection)
 
     connection.execute(
         "INSERT INTO engineering_schema_migrations(version) VALUES(?)",
@@ -1960,6 +1963,25 @@ def _migrate_schema_66(connection: sqlite3.Connection) -> None:
     connection.execute("UPDATE ep_installations SET schema_version=66")
 
 
+def _migrate_schema_67(connection: sqlite3.Connection) -> None:
+    """Add guarded terminal-evidence projection reconciliation."""
+    connection.execute("ALTER TABLE ep_installations RENAME TO ep_installations_schema66")
+    connection.execute(
+        "CREATE TABLE ep_installations (instance_id TEXT PRIMARY KEY,created_at TEXT NOT NULL,"
+        "schema_version INTEGER NOT NULL CHECK(schema_version IN "
+        "(41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67)))"
+    )
+    connection.execute(
+        "INSERT INTO ep_installations SELECT instance_id,created_at,67 "
+        "FROM ep_installations_schema66"
+    )
+    connection.execute("DROP TABLE ep_installations_schema66")
+    submission_service.install_terminal_evidence_reconciliation_schema(connection)
+    connection.execute("INSERT OR IGNORE INTO engineering_schema_migrations(version) VALUES(67)")
+    connection.execute("UPDATE engineering_metadata SET value='67' WHERE key='installation.schema_version'")
+    connection.execute("UPDATE ep_installations SET schema_version=67")
+
+
 _SERVER_SCHEMA_UPGRADE_STEPS = (
     (42, _migrate_schema_42),
     (43, _migrate_schema_43),
@@ -1986,6 +2008,7 @@ _SERVER_SCHEMA_UPGRADE_STEPS = (
     (64, _migrate_schema_64),
     (65, _migrate_schema_65),
     (66, _migrate_schema_66),
+    (67, _migrate_schema_67),
 )
 _SUPPORTED_SERVER_SCHEMA_VERSIONS = frozenset(
     range(41, SERVER_STORE_SCHEMA_VERSION + 1)
@@ -2026,6 +2049,8 @@ def validate_store(data_root: Path, identity: RuntimeIdentity) -> dict[str, obje
         "ep_execution_host_evidence_immutable_delete",
         "ep_technical_diagnostics_immutable_update",
         "ep_technical_diagnostics_immutable_delete",
+        "ep_terminal_evidence_reconciliation_immutable_update",
+        "ep_terminal_evidence_reconciliation_immutable_delete",
     } <= triggers and integrity == ["ok"] and metadata == {"installation.instance_id": identity.instance_id, "installation.schema_version": str(SERVER_STORE_SCHEMA_VERSION)} and installation is not None
     if not valid:
         raise ServerConfigurationError(
@@ -6174,7 +6199,7 @@ class _HealthHandler(http.server.BaseHTTPRequestHandler):
                 self._send(503, {"error": "CENTRAL_UNAVAILABLE"})
             return
         artifact = re.fullmatch(
-            r"/v1/projects/([^/]+)/artifacts/((?:terminal-evidence|assurance-findings):[^/]+)",
+            r"/v1/projects/([^/]+)/artifacts/((?:terminal-evidence(?:-reconciled)?|assurance-findings):[^/]+)",
             unquote(request.path),
         )
         if artifact:

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/submission_service.py

@@ -770,6 +770,51 @@ def _findings_artifact_id(run_id: str) -> str:
     return f"assurance-findings:{run_id}"
 
 
+def install_terminal_evidence_reconciliation_schema(connection: sqlite3.Connection) -> None:
+    """Install the one-run/one-current-projection repair authority."""
+    connection.executescript("""
+        CREATE TABLE IF NOT EXISTS ep_terminal_evidence_reconciliation_operations (
+            operation_id TEXT PRIMARY KEY,
+            run_id TEXT NOT NULL UNIQUE REFERENCES ep_execution_runs(run_id),
+            project_id TEXT NOT NULL REFERENCES ep_project_registrations(project_id),
+            source_artifact_id TEXT NOT NULL REFERENCES execution_artifact_records(artifact_id),
+            source_digest TEXT NOT NULL,
+            replacement_artifact_id TEXT NOT NULL UNIQUE REFERENCES execution_artifact_records(artifact_id),
+            replacement_digest TEXT NOT NULL,
+            reason_code TEXT NOT NULL CHECK(reason_code='MERGE_CANDIDATE_PROJECTION_V1'),
+            recorded_at TEXT NOT NULL
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS execution_artifact_records_active_terminal_run
+            ON execution_artifact_records(COALESCE(ep_run_id,run_id))
+            WHERE artifact_type='EP_TERMINAL_EVIDENCE'
+              AND projection_status='AVAILABLE'
+              AND COALESCE(ep_run_id,run_id) IS NOT NULL;
+        CREATE TRIGGER IF NOT EXISTS ep_terminal_evidence_reconciliation_immutable_update
+        BEFORE UPDATE ON ep_terminal_evidence_reconciliation_operations
+        BEGIN SELECT RAISE(ABORT, 'Terminal evidence reconciliation is immutable'); END;
+        CREATE TRIGGER IF NOT EXISTS ep_terminal_evidence_reconciliation_immutable_delete
+        BEFORE DELETE ON ep_terminal_evidence_reconciliation_operations
+        BEGIN SELECT RAISE(ABORT, 'Terminal evidence reconciliation is immutable'); END;
+    """)
+
+
+def _active_terminal_artifact(
+    connection: sqlite3.Connection, run_id: str,
+) -> tuple[object, ...] | None:
+    rows = connection.execute(
+        """SELECT artifact_id,digest_algorithm,digest,content_type,integrity_status,storage_location
+             FROM execution_artifact_records
+            WHERE artifact_type='EP_TERMINAL_EVIDENCE'
+              AND projection_status='AVAILABLE'
+              AND (ep_run_id=? OR (ep_run_id IS NULL AND run_id=?))
+            ORDER BY artifact_id LIMIT 2""",
+        (run_id, run_id),
+    ).fetchall()
+    if len(rows) > 1:
+        raise SubmissionError("TERMINAL_EVIDENCE_PROJECTION_AMBIGUOUS", 500)
+    return tuple(rows[0]) if rows else None
+
+
 def _current_assurance(checkpoint: object) -> tuple[str, list[dict[str, object]], list[dict[str, object]]]:
     """Project final assurance from one complete current review set.
 
@@ -973,6 +1018,17 @@ def write_terminal_evidence(
     artifact_id = _terminal_artifact_id(run_id)
     report_id = f"report:{run_id}"
     target = data_root / "artifacts" / "projects" / str(row[1]) / "runs" / run_id / "terminal-evidence-v1.json"
+    with sqlite_connection(database) as connection:
+        active_artifact = _active_terminal_artifact(connection, run_id)
+    if active_artifact is not None and verify_artifact_integrity(
+        repository_root, str(active_artifact[0]), central_database=database,
+        artifact_root=data_root / "artifacts",
+    ):
+        # Reconciliation may revisit a run after its original immutable
+        # projection was superseded through the guarded owning repair route.
+        # Return the one currently selected, integrity-verified artifact; do
+        # not reconstruct or overwrite either historical payload.
+        return str(active_artifact[0])
     if _is_retained_v13_terminal_artifact(
         target, run_id=run_id, submission_id=str(row[0]), project_id=str(row[1]),
         repository_id=str(row[2]),
@@ -980,10 +1036,6 @@ def write_terminal_evidence(
         repository_root, artifact_id, central_database=database,
         artifact_root=data_root / "artifacts",
     ):
-        # Reconciliation may revisit terminal runs long after a new artifact
-        # contract ships. The older evidence remains immutable and truthful;
-        # require its pre-existing CENTRAL digest record rather than adopting
-        # a same-account filesystem payload as evidence.
         return artifact_id
     assurance_status, current_reviews, reviews = _current_assurance(checkpoint)
     findings = [finding for review in reviews for finding in review.get("findings", [])]
@@ -1162,13 +1214,14 @@ def producer_readback(
             evidence["status"] = "INCOMPLETE"
         elif terminal:
             run.update(timing)
-            artifact = connection.execute(
-                """SELECT artifact_id,digest_algorithm,digest,content_type,integrity_status,storage_location
-                     FROM execution_artifact_records WHERE artifact_id=? AND (run_id=? OR ep_run_id=?)""",
-                (_terminal_artifact_id(str(run_id)), run_id, run_id),
-            ).fetchone()
+            try:
+                artifact = _active_terminal_artifact(connection, str(run_id))
+            except SubmissionError:
+                artifact = None
+                evidence["status"] = "CORRUPT"
             if artifact is None:
-                evidence["status"] = "MISSING"
+                if evidence["status"] != "CORRUPT":
+                    evidence["status"] = "MISSING"
             elif artifact[1] != "sha256" or not isinstance(artifact[2], str) or len(str(artifact[2])) != 64:
                 evidence["status"] = "CORRUPT"
             else:

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform/templates/workspace-config.json

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

engineering_platform-2.3.75/src/engineering_platform/terminal_evidence_reconciliation.py

@@ -0,0 +1,244 @@
+"""Guarded reconciliation of one known terminal-evidence projection defect.
+
+The route never changes a terminal run, accepted request, assurance record or
+historical artifact bytes.  It may add one corrected v1.4 projection only when
+the retained checkpoint and complete current assurance set prove that the
+legacy merge writer projected the execution baseline as its candidate.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import sqlite3
+
+from . import central_database, submission_service
+from .agent_state import RUN_ID_PATTERN, StateError, TransactionState
+from .storage import record_artifact, sqlite_connection
+
+
+_OPERATION_ID = re.compile(r"[a-z0-9][a-z0-9._:-]{7,127}\Z")
+_SHA = re.compile(r"[0-9a-f]{40}\Z")
+_REASON = "MERGE_CANDIDATE_PROJECTION_V1"
+
+
+class TerminalEvidenceReconciliationError(ValueError):
+    """A stable, secret-free refusal of a terminal-evidence repair."""
+
+
+def _result(row: tuple[object, ...]) -> dict[str, object]:
+    return {
+        "operation_id": str(row[0]),
+        "run_id": str(row[1]),
+        "project_id": str(row[2]),
+        "source_artifact_id": str(row[3]),
+        "source_digest": "sha256:" + str(row[4]),
+        "replacement_artifact_id": str(row[5]),
+        "replacement_digest": "sha256:" + str(row[6]),
+        "reason_code": str(row[7]),
+        "recorded_at": str(row[8]),
+        "state": "SUCCEEDED",
+    }
+
+
+def _operation(connection: sqlite3.Connection, operation_id: str) -> tuple[object, ...] | None:
+    row = connection.execute(
+        """SELECT operation_id,run_id,project_id,source_artifact_id,source_digest,
+                  replacement_artifact_id,replacement_digest,reason_code,recorded_at
+             FROM ep_terminal_evidence_reconciliation_operations
+            WHERE operation_id=?""",
+        (operation_id,),
+    ).fetchone()
+    return tuple(row) if row is not None else None
+
+
+def reconcile_terminal_evidence(
+    data_root: Path, *, run_id: str, operation_id: str,
+) -> dict[str, object]:
+    """Add and select one corrected projection while retaining original bytes."""
+    if RUN_ID_PATTERN.fullmatch(run_id) is None:
+        raise TerminalEvidenceReconciliationError("RUN_ID_INVALID")
+    if _OPERATION_ID.fullmatch(operation_id) is None:
+        raise TerminalEvidenceReconciliationError("OPERATION_ID_INVALID")
+    data_root = data_root.resolve()
+    database = central_database.path(data_root)
+    artifact_root = data_root / "artifacts"
+    with sqlite_connection(database) as connection:
+        existing = _operation(connection, operation_id)
+        if existing is not None:
+            if str(existing[1]) != run_id:
+                raise TerminalEvidenceReconciliationError("OPERATION_ID_CONFLICT")
+            return _result(existing)
+        conflicting = connection.execute(
+            "SELECT operation_id FROM ep_terminal_evidence_reconciliation_operations WHERE run_id=?",
+            (run_id,),
+        ).fetchone()
+        if conflicting is not None:
+            raise TerminalEvidenceReconciliationError("RUN_ALREADY_RECONCILED")
+        active = submission_service._active_terminal_artifact(connection, run_id)
+        row = connection.execute(
+            """SELECT d.project_id,d.repository_id,d.submission_id,t.payload
+                 FROM ep_parity_lifecycle_dispatches d
+                 JOIN engineering_transactions t ON t.run_id=d.run_id
+                WHERE d.run_id=? AND d.state='COMPLETE'""",
+            (run_id,),
+        ).fetchone()
+    if active is None or row is None:
+        raise TerminalEvidenceReconciliationError("TERMINAL_EVIDENCE_UNAVAILABLE")
+    source_id, algorithm, source_digest, _content_type, _integrity, source_location = active
+    if algorithm != "sha256" or not isinstance(source_digest, str):
+        raise TerminalEvidenceReconciliationError("SOURCE_ARTIFACT_INVALID")
+    try:
+        source_path = (artifact_root / str(source_location)).resolve()
+        source_path.relative_to(artifact_root.resolve())
+        source_bytes = source_path.read_bytes()
+        document = json.loads(source_bytes)
+        checkpoint = TransactionState.from_dict(json.loads(str(row[3])))
+    except (OSError, ValueError, TypeError, json.JSONDecodeError, StateError):
+        raise TerminalEvidenceReconciliationError("SOURCE_ARTIFACT_INVALID") from None
+    if hashlib.sha256(source_bytes).hexdigest() != source_digest:
+        raise TerminalEvidenceReconciliationError("SOURCE_ARTIFACT_INVALID")
+    assurance_status, current_reviews, _reviews = submission_service._current_assurance(checkpoint)
+    profile = checkpoint.assurance_profile
+    candidate = profile.get("candidate_sha") if isinstance(profile, dict) else None
+    repository = document.get("repository") if isinstance(document, dict) else None
+    submission = document.get("submission") if isinstance(document, dict) else None
+    producer = document.get("producer") if isinstance(document, dict) else None
+    run = document.get("run") if isinstance(document, dict) else None
+    assurance = document.get("assurance") if isinstance(document, dict) else None
+    if (
+        document.get("artifact_type") != "EP_TERMINAL_EVIDENCE"
+        or document.get("contract_version") != "1.4"
+        or not isinstance(repository, dict)
+        or not isinstance(submission, dict)
+        or not isinstance(producer, dict)
+        or not isinstance(run, dict)
+        or not isinstance(assurance, dict)
+        or run.get("id") != run_id
+        or run.get("outcome") != "COMPLETE"
+        or submission.get("id") != row[2]
+        or submission.get("project_id") != row[0]
+        or repository.get("id") != row[1]
+        or not isinstance(producer.get("id"), str)
+        or checkpoint.run_id != run_id
+        or not checkpoint.terminal
+        or checkpoint.phase != "COMPLETE"
+        or checkpoint.action_intent != "MUTATING_DELIVERY"
+        or assurance_status != "PASS"
+        or not isinstance(candidate, str)
+        or _SHA.fullmatch(candidate) is None
+        or assurance.get("profile") != profile
+        or len(current_reviews) < 2
+    ):
+        raise TerminalEvidenceReconciliationError("RECONCILIATION_PRECONDITION_FAILED")
+    projected_candidate = repository.get("candidate")
+    if (
+        projected_candidate != checkpoint.implementation_head_sha
+        or projected_candidate != checkpoint.execution_baseline_sha
+        or projected_candidate == candidate
+    ):
+        raise TerminalEvidenceReconciliationError("RECONCILIATION_DEFECT_NOT_PRESENT")
+
+    corrected = dict(document)
+    corrected["repository"] = {**repository, "candidate": candidate}
+    replacement_bytes = submission_service._canonical_json_bytes(corrected)
+    replacement_digest = hashlib.sha256(replacement_bytes).hexdigest()
+    replacement_id = f"terminal-evidence-reconciled:{run_id}:{replacement_digest[:16]}"
+    replacement_path = source_path.with_name(
+        f"terminal-evidence-v1-reconciled-{replacement_digest[:16]}.json"
+    )
+    submission_service._write_immutable_artifact(replacement_path, replacement_bytes)
+    record_artifact(
+        data_root,
+        replacement_path,
+        artifact_id=replacement_id,
+        artifact_type="EP_TERMINAL_EVIDENCE",
+        content_type="application/json",
+        created_at=datetime_now(),
+        run_id=run_id,
+        submission_id=str(row[2]),
+        producer_id=str(producer["id"]),
+        ep_run_id=run_id,
+        ep_submission_id=str(row[2]),
+        projection_status="CANDIDATE",
+        central_database=database,
+        artifact_root=artifact_root,
+    )
+    recorded_at = datetime_now()
+    with sqlite_connection(database) as connection:
+        try:
+            connection.execute("BEGIN IMMEDIATE")
+            existing = _operation(connection, operation_id)
+            if existing is not None:
+                connection.execute("ROLLBACK")
+                if str(existing[1]) != run_id:
+                    raise TerminalEvidenceReconciliationError("OPERATION_ID_CONFLICT")
+                return _result(existing)
+            active_now = submission_service._active_terminal_artifact(connection, run_id)
+            if active_now is None or str(active_now[0]) != str(source_id) or str(active_now[2]) != source_digest:
+                raise TerminalEvidenceReconciliationError("SOURCE_ARTIFACT_CHANGED")
+            connection.execute(
+                """INSERT INTO ep_terminal_evidence_reconciliation_operations(
+                    operation_id,run_id,project_id,source_artifact_id,source_digest,
+                    replacement_artifact_id,replacement_digest,reason_code,recorded_at
+                ) VALUES(?,?,?,?,?,?,?,?,?)""",
+                (
+                    operation_id, run_id, str(row[0]), str(source_id), source_digest,
+                    replacement_id, replacement_digest, _REASON, recorded_at,
+                ),
+            )
+            source_updated = connection.execute(
+                """UPDATE execution_artifact_records SET projection_status='SUPERSEDED'
+                    WHERE artifact_id=? AND digest=? AND projection_status='AVAILABLE'""",
+                (str(source_id), source_digest),
+            )
+            replacement_updated = connection.execute(
+                """UPDATE execution_artifact_records SET projection_status='AVAILABLE'
+                    WHERE artifact_id=? AND digest=? AND projection_status='CANDIDATE'""",
+                (replacement_id, replacement_digest),
+            )
+            if source_updated.rowcount != 1 or replacement_updated.rowcount != 1:
+                raise TerminalEvidenceReconciliationError("PROJECTION_TRANSITION_CONFLICT")
+            connection.execute("COMMIT")
+        except Exception:
+            try:
+                connection.execute("ROLLBACK")
+            except sqlite3.DatabaseError:
+                pass
+            raise
+        result = _operation(connection, operation_id)
+    if result is None:
+        raise TerminalEvidenceReconciliationError("RECONCILIATION_RECEIPT_UNAVAILABLE")
+    return _result(result)
+
+
+def datetime_now() -> str:
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).isoformat()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="engineering-terminal-evidence-reconcile",
+        description="Reconcile one exact historical terminal candidate projection.",
+    )
+    parser.add_argument("--data-root", type=Path, required=True)
+    parser.add_argument("--run-id", required=True)
+    parser.add_argument("--operation-id", required=True)
+    args = parser.parse_args(argv)
+    try:
+        result = reconcile_terminal_evidence(
+            args.data_root, run_id=args.run_id, operation_id=args.operation_id,
+        )
+    except TerminalEvidenceReconciliationError as error:
+        print(json.dumps({"state": "BLOCKED", "reason_code": str(error)}, sort_keys=True))
+        return 2
+    print(json.dumps(result, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform.egg-info/PKG-INFO

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

{engineering_platform-2.3.73 → engineering_platform-2.3.75}/src/engineering_platform.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ src/engineering_platform/submission_service.py
 src/engineering_platform/system_installation_topology.py
 src/engineering_platform/system_server_service.py
 src/engineering_platform/telemetry.py
+src/engineering_platform/terminal_evidence_reconciliation.py
 src/engineering_platform/validation_identity.py
 src/engineering_platform/validation_profile.py
 src/engineering_platform/version_preparation_delivery.py