engineering-platform 2.3.90__tar.gz → 2.3.91__tar.gz

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/PKG-INFO

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

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/pyproject.toml

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

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/ENGINEERING_PLATFORM_CONFIG.json

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

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/ENGINEERING_PLATFORM_VERSION.json

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

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/execution_host.py

@@ -3086,6 +3086,15 @@ First implementation pull-request publication gate:
                 "Accepted repository revision binding is invalid.",
             )
         if revision_binding is not None:
+            if (revision_binding.repository_identity is not None
+                    and (evidence.repository != revision_binding.repository_identity
+                         or not callable(getattr(self.repository, "trusted_origin_identity", None))
+                         or self.repository.trusted_origin_identity(self.root)
+                         != revision_binding.repository_identity)):
+                return self._save_terminal(
+                    state, "BLOCKED", "repository_identity_binding",
+                    "Managed workspace origin differs from the authorized repository identity.",
+                )
             if state.requested_repository_revision not in {None, revision_binding.requested_revision}:
                 return self._save_terminal(
                     state, "BLOCKED", "repository_revision_binding",
@@ -3212,10 +3221,47 @@ First implementation pull-request publication gate:
         self.transaction = self.transaction.with_lease(self.active_lease)
         self.lease_heartbeat.start()
         if recovered_resume:
+            self._heartbeat()
+            if revision_binding is not None and context.execution_mode == "MANAGED":
+                recovered_head = self.repository.inspect(self.root)
+                expected_baseline = (
+                    revision_binding.allowed_baseline_revision
+                    or revision_binding.requested_revision
+                )
+                if (state.execution_baseline_sha != expected_baseline
+                        or recovered_head.repository != state.repository
+                        or not recovered_head.clean
+                        or self.repository.workspace_operation_active(self.root)
+                        or (state.branch is not None and recovered_head.branch not in {state.branch, "main"})
+                        or not callable(getattr(self.repository, "trusted_origin_identity", None))
+                        or self.repository.trusted_origin_identity(self.root) != state.repository
+                        or not callable(getattr(self.repository, "revision_is_ancestor", None))
+                        or not self.repository.revision_is_ancestor(
+                            self.root, expected_baseline, recovered_head.head_sha,
+                        )):
+                    return self._save_terminal(
+                        state, "BLOCKED", "recovered_workspace_baseline",
+                        "Recovered provider result lacks the authorized workspace baseline.",
+                    )
             # Consume immutable attempt-two evidence before any fresh provider
             # preparation or repository synchronization. This preserves the
             # original branch/worktree and cannot allocate a new invocation.
             result = self._invoke_agent_with_timing(state, "")
+            if (revision_binding is not None and context.execution_mode == "MANAGED"
+                    and recovery_snapshot["lifecycle_phase"] == "EXECUTE_AGENT"
+                    and result.terminal_state == "COMPLETE"):
+                result_head = self.repository.inspect(self.root)
+                if (not result.commit_sha or not result.branch
+                        or result_head.head_sha != result.commit_sha
+                        or result_head.branch != result.branch or not result_head.clean
+                        or self.repository.trusted_origin_identity(self.root) != state.repository
+                        or not self.repository.revision_is_ancestor(
+                            self.root, state.execution_baseline_sha, result.commit_sha,
+                        )):
+                    return self._save_terminal(
+                        state, "BLOCKED", "recovered_workspace_result_drift",
+                        "Recovered provider result no longer matches the bound workspace commit.",
+                    )
             state = self._record_agent_execution_time(state)
             state = self._record_validation_evidence(state, result)
             state = self._record_verified_result_commit(
@@ -3229,10 +3275,18 @@ First implementation pull-request publication gate:
         # and so the bounded retry policy in the repository client is used.
         if context.execution_mode == "MANAGED":
             try:
-                # A pin is a pre-mutation contract: never synchronize it to a
-                # newer ambient main. A named transition is explicit and is
-                # verified immediately after the normal host-owned sync.
-                if revision_binding is None or revision_binding.allowed_baseline_revision is not None:
+                # An exact pin is prepared by the owning repository client
+                # under this lease. It may fast forward only to that SHA,
+                # never to an ambient newer origin/main.
+                if revision_binding is not None and revision_binding.allowed_baseline_revision is None:
+                    prepare = getattr(self.repository, "prepare_main_revision", None)
+                    if not callable(prepare):
+                        raise RunnerError("MANAGED_PREPARATION_UNAVAILABLE")
+                    evidence = prepare(
+                        self.root, revision_binding.requested_revision,
+                        revision_binding.repository_identity or state.repository,
+                    )
+                else:
                     self.repository.synchronize_main(self.root)
                 # The initial observation predates lease acquisition. Always
                 # refresh it here: an exact pin skips synchronization, never
@@ -3326,6 +3380,19 @@ First implementation pull-request publication gate:
             self.reviewer_runtime,
         )
         self._require_provider_dispatch_admission(state)
+        self._heartbeat()
+        if state.execution_mode == "MANAGED" and state.execution_baseline_sha is not None:
+            reviewer_head = self.repository.inspect(self.root)
+            if (reviewer_head.repository != state.repository or reviewer_head.branch != "main"
+                    or not reviewer_head.clean or reviewer_head.head_sha != state.execution_baseline_sha
+                    or self.repository.workspace_operation_active(self.root)
+                    or (state.requested_repository_revision is not None
+                        and self.repository.trusted_origin_identity(self.root) != state.repository)):
+                complete_phase(self.root, capability_review, outcome="FAILED")
+                return self._save_terminal(
+                    state, "BLOCKED", "managed_workspace_drift",
+                    "Managed workspace changed after baseline admission and before capability review.",
+                )
         results = run_reviews(
             self.root,
             selections,
@@ -3426,6 +3493,18 @@ First implementation pull-request publication gate:
                         ),
                     )[1]
                 )
+            if state.execution_mode == "MANAGED" and state.execution_baseline_sha is not None:
+                self._heartbeat()
+                execution_head = self.repository.inspect(self.root)
+                if (execution_head.repository != state.repository or execution_head.branch != "main"
+                        or not execution_head.clean or execution_head.head_sha != state.execution_baseline_sha
+                        or self.repository.workspace_operation_active(self.root)
+                        or (state.requested_repository_revision is not None
+                            and self.repository.trusted_origin_identity(self.root) != state.repository)):
+                    return self._save_terminal(
+                        state, "BLOCKED", "managed_workspace_drift",
+                        "Managed workspace changed after baseline admission and before provider implementation.",
+                    )
             result = self._invoke_agent_with_timing(
                 state,
                 assemble_prompt(

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/execution_repository.py

@@ -31,6 +31,18 @@ def github_repository_slug(remote: str) -> str:
     return value
 
 
+def trusted_github_repository_slug(remote: str) -> str | None:
+    """Resolve only an authorized GitHub transport, never a path or alias."""
+    value = remote.strip()
+    if value.startswith("git@github.com:"):
+        slug = value.removeprefix("git@github.com:").removesuffix(".git")
+    elif value.startswith("https://github.com/"):
+        slug = value.removeprefix("https://github.com/").removesuffix(".git")
+    else:
+        return None
+    return slug if re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", slug) else None
+
+
 class RepositoryClient(Protocol):
     def inspect(self, root: Path) -> RepositoryEvidence: ...
     def main_contains(self, root: Path, sha: str) -> bool: ...
@@ -38,6 +50,10 @@ class RepositoryClient(Protocol):
     def refresh_main_reference(self, root: Path) -> None: ...
     def remote_main_contains(self, root: Path, sha: str) -> bool: ...
     def synchronize_main(self, root: Path) -> None: ...
+    def prepare_main_revision(self, root: Path, revision: str, repository_id: str) -> RepositoryEvidence: ...
+    def revision_is_ancestor(self, root: Path, ancestor: str, descendant: str) -> bool: ...
+    def trusted_origin_identity(self, root: Path) -> str | None: ...
+    def workspace_operation_active(self, root: Path) -> bool: ...
 
 
 class GitHubClient(Protocol):
@@ -73,6 +89,19 @@ class SubprocessRepositoryClient:
         contained = self.provider.execute(root, "git", "merge-base", "--is-ancestor", head_sha, "main").returncode == 0
         return RepositoryEvidence(repository, branch, head_sha, clean, contained)
 
+    def trusted_origin_identity(self, root: Path) -> str | None:
+        return trusted_github_repository_slug(self._run(root, "git", "remote", "get-url", "origin"))
+
+    def workspace_operation_active(self, root: Path) -> bool:
+        for name in ("index.lock", "MERGE_HEAD", "REBASE_HEAD", "CHERRY_PICK_HEAD",
+                     "REVERT_HEAD", "BISECT_LOG", "rebase-merge", "rebase-apply"):
+            path = Path(self._run(root, "git", "rev-parse", "--git-path", name))
+            if not path.is_absolute():
+                path = root / path
+            if path.exists():
+                return True
+        return False
+
     def main_contains(self, root: Path, sha: str) -> bool:
         return self.provider.execute(root, "git", "merge-base", "--is-ancestor", sha, "main").returncode == 0
 
@@ -91,6 +120,13 @@ class SubprocessRepositoryClient:
     def remote_main_contains(self, root: Path, sha: str) -> bool:
         return self.provider.execute(root, "git", "merge-base", "--is-ancestor", sha, "origin/main").returncode == 0
 
+    def revision_is_ancestor(self, root: Path, ancestor: str, descendant: str) -> bool:
+        if not all(re.fullmatch(r"[0-9a-f]{40}", value) for value in (ancestor, descendant)):
+            return False
+        return self.provider.execute(
+            root, "git", "merge-base", "--is-ancestor", ancestor, descendant,
+        ).returncode == 0
+
     @staticmethod
     def _is_transient_index_lock_conflict(error: RuntimeError) -> bool:
         """Recognize only Git's contention signal, never a permission failure."""
@@ -180,6 +216,46 @@ class SubprocessRepositoryClient:
                 f"{self._managed_sync_diagnostics(root)}; {self._managed_sync_error_detail(error)}"
             ) from error
 
+    def prepare_main_revision(self, root: Path, revision: str, repository_id: str) -> RepositoryEvidence:
+        """Fast forward a clean Managed main to one authorized protected revision.
+
+        The caller owns the execution lease.  This method never resets local
+        work, switches branches, or treats a branch name as commit evidence.
+        """
+        if re.fullmatch(r"[0-9a-f]{40}", revision) is None:
+            raise RunnerError("MANAGED_PREPARATION_INVALID_REVISION")
+        before = self.inspect(root)
+        if self.trusted_origin_identity(root) != repository_id:
+            raise RunnerError("MANAGED_PREPARATION_ORIGIN_UNTRUSTED")
+        if before.repository != repository_id:
+            raise RunnerError("MANAGED_PREPARATION_REPOSITORY_MISMATCH")
+        if before.branch != "main" or not before.clean or not before.main_contains_head:
+            raise RunnerError("MANAGED_PREPARATION_UNSAFE_WORKTREE")
+        if self.workspace_operation_active(root):
+            raise RunnerError("MANAGED_PREPARATION_GIT_OPERATION_ACTIVE")
+        self._synchronize_command(root, "git", "fetch", "--prune", "origin", "main")
+        if not self.remote_main_contains(root, revision):
+            raise RunnerError("MANAGED_PREPARATION_REVISION_NOT_ON_PROTECTED_MAIN")
+        if before.head_sha == revision:
+            if (self.inspect(root) != before or self.trusted_origin_identity(root) != repository_id
+                    or self.workspace_operation_active(root)):
+                raise RunnerError("MANAGED_PREPARATION_WORKSPACE_DRIFT")
+            return before
+        if self.provider.execute(root, "git", "merge-base", "--is-ancestor", before.head_sha, revision).returncode:
+            raise RunnerError("MANAGED_PREPARATION_NON_FAST_FORWARD")
+        after_fetch = self.inspect(root)
+        if (after_fetch != before or self.trusted_origin_identity(root) != repository_id
+                or self.workspace_operation_active(root)):
+            raise RunnerError("MANAGED_PREPARATION_WORKSPACE_DRIFT")
+        self._synchronize_command(root, "git", "merge", "--ff-only", revision)
+        prepared = self.inspect(root)
+        if (prepared.repository != repository_id or prepared.branch != "main" or not prepared.clean
+                or not prepared.main_contains_head or prepared.head_sha != revision
+                or self.trusted_origin_identity(root) != repository_id
+                or self.workspace_operation_active(root)):
+            raise RunnerError("MANAGED_PREPARATION_RESULT_UNCERTAIN")
+        return prepared
+
     def cleanup_transaction(self, root: Path, branches: tuple[str | None, ...]) -> str:
         self._run(root, "git", "fetch", "--prune"); self.synchronize_main(root)
         if not self.inspect(root).clean: raise RunnerError("Cleanup blocked: workspace is not clean.")

engineering_platform-2.3.91/src/engineering_platform/managed_workspace_readiness.py

@@ -0,0 +1,85 @@
+"""Read-only, project-scoped Managed workspace capability inspection."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+import re
+import sqlite3
+
+from .execution_repository import trusted_github_repository_slug
+from .providers import GitProvider
+
+
+def project_readiness(connection: sqlite3.Connection, *, project_id: str,
+                      repository_id: str) -> dict[str, object]:
+    """Report known blockers without planning or changing the checkout."""
+    observed_at = datetime.now(timezone.utc).isoformat()
+    binding = connection.execute(
+        "SELECT b.local_root FROM ep_local_repository_bindings b "
+        "JOIN ep_repository_registrations r ON r.repository_id=b.repository_id "
+        "AND r.project_id=b.project_id AND r.role='authority' "
+        "WHERE b.project_id=? AND b.repository_id=? AND b.state='BOUND'",
+        (project_id, repository_id),
+    ).fetchone()
+    response: dict[str, object] = {
+        "contract_version": "1.0", "project_id": project_id,
+        "repository_id": repository_id,
+        "managed_workspace_id": f"{project_id}:{repository_id}",
+        "execution_mode": "MANAGED", "repository_identity": None,
+        "origin": None, "head_sha": None, "branch": None, "clean": None,
+        "busy": None, "active_lease": None,
+        "preparation_capability": "EXACT_MAIN_FAST_FORWARD_V1",
+        "status": "BLOCKED", "known_blocker": "MANAGED_WORKSPACE_UNBOUND",
+        "observed_at": observed_at,
+    }
+    if binding is None:
+        return response
+    root = Path(str(binding[0]))
+    git = GitProvider()
+
+    def read(*args: str) -> str | None:
+        try:
+            result = git.execute(root, "git", *args)
+        except (OSError, RuntimeError):
+            return None
+        return result.stdout.strip() if result.returncode == 0 else None
+
+    head = read("rev-parse", "--verify", "HEAD")
+    branch = read("branch", "--show-current")
+    remote = read("remote", "get-url", "origin")
+    status = read("status", "--porcelain", "--untracked-files=all")
+    identity = trusted_github_repository_slug(remote) if remote else None
+    active_lease = connection.execute(
+        "SELECT 1 FROM execution_run_leases l JOIN ep_execution_runs r ON r.run_id=l.run_id "
+        "WHERE r.project_id=? AND l.lease_state='ACTIVE' LIMIT 1",
+        (project_id,),
+    ).fetchone() is not None
+    operation = False
+    for name in ("index.lock", "MERGE_HEAD", "REBASE_HEAD", "CHERRY_PICK_HEAD",
+                 "REVERT_HEAD", "BISECT_LOG", "rebase-merge", "rebase-apply"):
+        marker = read("rev-parse", "--git-path", name)
+        if marker is None:
+            operation = True
+            break
+        path = Path(marker)
+        if (path if path.is_absolute() else root / path).exists():
+            operation = True
+            break
+    blocker = (
+        "MANAGED_WORKSPACE_UNAVAILABLE" if head is None or status is None or branch is None
+        or re.fullmatch(r"[0-9a-f]{40}", head) is None else
+        "MANAGED_ORIGIN_UNTRUSTED" if identity is None else
+        "MANAGED_BRANCH_UNEXPECTED" if branch != "main" else
+        "MANAGED_WORKSPACE_DIRTY" if status else
+        "MANAGED_GIT_OPERATION_ACTIVE" if operation else
+        "MANAGED_LEASE_ACTIVE" if active_lease else None
+    )
+    response.update({
+        "repository_identity": identity, "origin": identity,
+        "head_sha": head if head and re.fullmatch(r"[0-9a-f]{40}", head) else None,
+        "branch": branch, "clean": status == "" if status is not None else None,
+        "busy": operation or active_lease, "active_lease": active_lease,
+        "status": "READY" if blocker is None else "BLOCKED", "known_blocker": blocker,
+    })
+    return response

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/parity_context.py

@@ -78,8 +78,11 @@ class ParityProjectStore:
 
     def queued_submissions(self) -> list[dict[str, object]]:
         rows = self.connection.execute(
-            "SELECT submission_id,repository_id,state,admission,created_at,prompt_digest "
-            "FROM ep_submissions WHERE project_id=? ORDER BY created_at,submission_id",
+            "SELECT s.submission_id,s.repository_id,s.state,s.admission,s.created_at,s.prompt_digest "
+            "FROM ep_submissions AS s LEFT JOIN ep_parity_lifecycle_dispatches AS d "
+            "ON d.submission_id=s.submission_id WHERE s.project_id=? AND d.submission_id IS NULL "
+            "AND s.state='QUEUED' AND s.admission='ADMITTED' "
+            "ORDER BY s.created_at,s.submission_id",
             (self.context.project_id,),
         ).fetchall()
         return [{"submission_id": str(row[0]), "repository_id": str(row[1]), "state": str(row[2]),

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/parity_lifecycle_dispatcher.py

@@ -117,6 +117,8 @@ def _retry_constraints_for_current_main(
         "requested_revision": binding.requested_revision,
         "allowed_baseline_revision": current_main,
     }
+    if binding.repository_identity is not None:
+        rebound[CONSTRAINT_KEY]["repository_identity"] = binding.repository_identity
     return rebound
 
 
@@ -477,7 +479,12 @@ class ParityLifecycleDispatcher:
             retry_parent_run_id=candidate.retry_parent_run_id, resume_parent_run_id=None, recorded_at=now,
         )
         host = execute_host_preflight(repository_root, run_id=run_id)
-        workspace = execute_workspace_preflight(repository_root, candidate.prompt, run_id=run_id)
+        revision_binding = parse_repository_revision_binding(candidate.constraints)
+        workspace = execute_workspace_preflight(
+            repository_root, candidate.prompt, run_id=run_id,
+            **({"exact_revision_preparation": True}
+               if revision_binding is not None and revision_binding.allowed_baseline_revision is None else {}),
+        )
         capability = execute_capability_preflight(repository_root, candidate.prompt, run_id=run_id)
         decision, _ = _record_provider_free_admission(
             repository_root, run_id=run_id, submission_id=canonical_submission_id,

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/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.90"
+CURRENT_PLATFORM_VERSION = "2.3.91"
 MANIFEST_FIELDS = frozenset(
     {
         "platform_version",

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/revision_binding.py

@@ -17,6 +17,7 @@ class RepositoryRevisionBinding:
 
     requested_revision: str
     allowed_baseline_revision: str | None = None
+    repository_identity: str | None = None
 
 
 def parse_repository_revision_binding(
@@ -26,9 +27,10 @@ def parse_repository_revision_binding(
     if constraints is None or CONSTRAINT_KEY not in constraints:
         return None
     raw = constraints[CONSTRAINT_KEY]
-    if not isinstance(raw, Mapping) or set(raw) != {
-        "requested_revision", "allowed_baseline_revision",
-    }:
+    if not isinstance(raw, Mapping) or set(raw) not in (
+        {"requested_revision", "allowed_baseline_revision"},
+        {"requested_revision", "allowed_baseline_revision", "repository_identity"},
+    ):
         raise ValueError("repository revision binding shape is invalid")
     requested = raw.get("requested_revision")
     allowed = raw.get("allowed_baseline_revision")
@@ -36,4 +38,8 @@ def parse_repository_revision_binding(
         raise ValueError("requested repository revision is invalid")
     if allowed is not None and (not isinstance(allowed, str) or _SHA.fullmatch(allowed) is None):
         raise ValueError("allowed baseline repository revision is invalid")
-    return RepositoryRevisionBinding(requested, allowed)
+    identity = raw.get("repository_identity")
+    if identity is not None and (not isinstance(identity, str)
+                                 or re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", identity) is None):
+        raise ValueError("repository identity is invalid")
+    return RepositoryRevisionBinding(requested, allowed, identity)

engineering_platform-2.3.91/src/engineering_platform/schemas/producer-readback-v1.3.schema.json

@@ -0,0 +1,103 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://engineering-platform.local/schemas/producer-readback-v1.3.schema.json",
+  "title": "Engineering Platform producer readback v1.3 current execution disposition",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["contract_version", "submission", "producer", "correlation", "provenance", "disposition", "run", "result", "evidence"],
+  "properties": {
+    "contract_version": {"const": "1.3"},
+    "submission": {
+      "type": "object", "additionalProperties": false,
+      "required": ["id", "project_id", "repository_id", "state", "admission", "transport", "created_at", "accepted_request_digest"],
+      "properties": {
+        "id": {"type": "string"}, "project_id": {"type": "string"},
+        "repository_id": {"type": "string"}, "state": {"type": "string"},
+        "admission": {"type": "string"}, "transport": {"type": "string"},
+        "created_at": {"type": "string"},
+        "accepted_request_digest": {"type": "string", "pattern": "^sha256:[0-9a-f]{64}$"}
+      }
+    },
+    "producer": {
+      "type": "object", "additionalProperties": false,
+      "required": ["id", "type", "version"],
+      "properties": {
+        "id": {"type": "string"}, "type": {"type": "string"},
+        "version": {"type": ["string", "null"]}
+      }
+    },
+    "correlation": {
+      "type": "object", "additionalProperties": false,
+      "required": ["correlation_id", "mission_id", "engineering_action_id"],
+      "properties": {
+        "correlation_id": {"type": ["string", "null"]},
+        "mission_id": {"type": ["string", "null"]},
+        "engineering_action_id": {"type": ["string", "null"]}
+      }
+    },
+    "provenance": {
+      "type": "object", "additionalProperties": false,
+      "required": ["status", "forge_execution"],
+      "properties": {
+        "status": {"type": "string"},
+        "forge_execution": {"type": ["object", "null"]}
+      }
+    },
+    "disposition": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["state", "terminal", "execution_eligible", "revision", "operation_id", "event_reference", "reason", "actor_reference", "recorded_at", "resolution_submission_id", "retry_parent_run_id"],
+      "properties": {
+        "state": {"enum": ["QUEUED", "DEFERRED", "QUARANTINED", "DECLINED", "CLAIMED", "RUNNING", "COMPLETE", "BLOCKED", "FAILED", "DISMISSED"]},
+        "terminal": {"type": "boolean"},
+        "execution_eligible": {"type": "boolean"},
+        "revision": {"type": "integer", "minimum": 0},
+        "operation_id": {"type": ["string", "null"]},
+        "event_reference": {"type": ["string", "null"]},
+        "reason": {"type": "string"},
+        "actor_reference": {"type": "string"},
+        "recorded_at": {"type": ["string", "null"]},
+        "resolution_submission_id": {"type": ["string", "null"]},
+        "retry_parent_run_id": {"type": ["string", "null"]}
+      }
+    },
+    "run": {
+      "type": ["object", "null"],
+      "properties": {
+        "id": {"type": "string", "minLength": 1},
+        "state": {"type": "string", "minLength": 1},
+        "terminal": {"type": "boolean"},
+        "operator_resolution": {"type": "string"},
+        "updated_at": {"type": "string"},
+        "execution_started_at": {"type": "string", "format": "date-time"},
+        "execution_completed_at": {"type": "string", "format": "date-time"},
+        "execution_duration_ms": {"type": "integer", "minimum": 1}
+      }
+    },
+    "result": {
+      "type": "object", "additionalProperties": false,
+      "required": ["outcome", "terminal", "delivery_qualified"],
+      "properties": {
+        "outcome": {"type": "string"},
+        "terminal": {"type": "boolean"},
+        "delivery_qualified": {"type": "boolean"}
+      }
+    },
+    "evidence": {
+      "type": "object", "additionalProperties": false,
+      "required": ["status", "terminal_artifact", "repository"],
+      "properties": {
+        "status": {"type": "string"},
+        "terminal_artifact": {"type": ["object", "null"]},
+        "repository": {
+          "type": "object", "additionalProperties": false,
+          "required": ["id", "revision"],
+          "properties": {
+            "id": {"type": ["string", "null"]},
+            "revision": {"type": ["string", "null"]}
+          }
+        }
+      }
+    }
+  }
+}

{engineering_platform-2.3.90 → engineering_platform-2.3.91}/src/engineering_platform/server.py

@@ -77,6 +77,7 @@ from . import system_server_service
 from . import storage
 from . import telemetry_export
 from . import managed_codex_runtime
+from . import managed_workspace_readiness
 from . import provider_readiness
 from .platform_components import (
     PLATFORM_COMPONENT_BY_ID,
@@ -3972,7 +3973,7 @@ def _no_project_console_snapshot(data_root: Path) -> dict[str, object]:
         ).fetchone()[0])
         queue_depth = int(connection.execute(
             """SELECT COUNT(*) FROM ep_submissions AS submission
-                 WHERE submission.state IN ('QUEUED','ADMITTED')
+                 WHERE submission.state='QUEUED' AND submission.admission='ADMITTED'
                    AND NOT EXISTS (
                        SELECT 1 FROM ep_parity_lifecycle_dispatches AS dispatch
                         WHERE dispatch.submission_id=submission.submission_id
@@ -6971,7 +6972,7 @@ class _HealthHandler(http.server.BaseHTTPRequestHandler):
                 "producer": {"id": "engineering-platform", "version": CURRENT_PLATFORM_VERSION},
                 "instance": {"id": identity},
                 "contracts": {
-                    "producer_readback": [submission_service.PRODUCER_READBACK_CONTRACT_VERSION],
+                    "producer_readback": [submission_service.PRODUCER_READBACK_CONTRACT_VERSION, "1.3"],
                     "terminal_evidence": [submission_service.TERMINAL_EVIDENCE_CONTRACT_VERSION],
                 },
             }
@@ -7044,6 +7045,29 @@ class _HealthHandler(http.server.BaseHTTPRequestHandler):
                 return
             self._send(200, declaration, identity)
             return
+        workspace_readiness = re.fullmatch(
+            r"/v1/projects/([^/]+)/managed-workspace-readiness", request.path,
+        )
+        if workspace_readiness:
+            project_id = workspace_readiness.group(1)
+            repository_id = self.headers.get("EP-Repository-ID")
+            authorization = self.headers.get("Authorization", "")
+            token = authorization[7:] if authorization.startswith("Bearer ") else None
+            try:
+                with storage.sqlite_connection(self.server.data_root / SERVER_DATABASE_FILENAME) as connection:  # type: ignore[attr-defined]
+                    if _authenticated_consumer(connection, token, project_id) is None:
+                        self._send(401, {"error": "UNAUTHENTICATED"})
+                        return
+                    if not repository_id:
+                        self._send(400, {"error": "REPOSITORY_SCOPE_REQUIRED"})
+                        return
+                    readiness = managed_workspace_readiness.project_readiness(
+                        connection, project_id=project_id, repository_id=repository_id,
+                    )
+                self._send(200, readiness, initialize(self.server.data_root).instance_id)  # type: ignore[attr-defined]
+            except sqlite3.Error:
+                self._send(503, {"error": "CENTRAL_UNAVAILABLE"})
+            return
         if request.path == "/diagnostics/topology":
             try:
                 self._send(200, operations_projection(self.server.data_root), initialize(self.server.data_root).instance_id)  # type: ignore[attr-defined]
@@ -7121,6 +7145,10 @@ class _HealthHandler(http.server.BaseHTTPRequestHandler):
                         return
                     projection = submission_service.producer_readback(
                         connection, project_id=project_id, submission_id=submission_id,
+                        contract_version=(
+                            "1.3" if self.headers.get("EP-Producer-Readback-Contract") == "1.3"
+                            else "1.2"
+                        ),
                     )
                 if projection is None:
                     self._send(404, {"error": "SUBMISSION_NOT_FOUND"})
@@ -8258,7 +8286,7 @@ def main(argv: list[str] | None = None) -> int:
                         early = {"diagnostic_code": "EARLY_FAILURE_EVIDENCE_UNAVAILABLE"}
             receipt_complete = transport != "FILE_INBOX" or (isinstance(receipt_id, str) and bool(receipt_id) and isinstance(received_at, str) and bool(received_at))
             scope_complete = run_id is not None and (dispatch_project, dispatch_repository) == (project_id, repository_id)
-            result = {"submission_id": args.submission_id, "project_id": project_id, "repository_id": repository_id, "submission_state": state, "admission": admission, "run_id": run_id, "dispatch_state": dispatch_state, "operator_resolution": resolution, "transport_provenance": "COMPLETE" if receipt_complete else "INCOMPLETE", "admission_audit_provenance": "PRESENT" if admission_audit else "UNAVAILABLE", "receipt_run_provenance": "PRESENT" if run_id else "UNAVAILABLE", "dispatch_scope_provenance": "COMPLETE" if scope_complete else "UNAVAILABLE", "lane_blocker": {"run_id": blocked[0], "state": blocked[1]} if blocked else None, "early_failure": early, "worker_eligible": state == "QUEUED" and admission == "ADMITTED" and blocked is None}
+            result = {"submission_id": args.submission_id, "project_id": project_id, "repository_id": repository_id, "submission_state": state, "admission": admission, "run_id": run_id, "dispatch_state": dispatch_state, "operator_resolution": resolution, "transport_provenance": "COMPLETE" if receipt_complete else "INCOMPLETE", "admission_audit_provenance": "PRESENT" if admission_audit else "UNAVAILABLE", "receipt_run_provenance": "PRESENT" if run_id else "UNAVAILABLE", "dispatch_scope_provenance": "COMPLETE" if scope_complete else "UNAVAILABLE", "lane_blocker": {"run_id": blocked[0], "state": blocked[1]} if blocked else None, "early_failure": early, "worker_eligible": state == "QUEUED" and admission == "ADMITTED" and run_id is None and blocked is None}
         elif args.command == "register-topology":
             if args.declaration is None:
                 raise ServerConfigurationError("--declaration is required for explicit topology registration.")