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

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.90"
+version = "2.3.92"
 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.92}/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.92",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.90 → engineering_platform-2.3.92}/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.92",
   "handoff_protocol": 1,
   "memory_format": 2,
   "minimum_codex_cli": "0.146.0",
   "inbox_protocol": 1,
-  "platform_version": "2.3.90",
+  "platform_version": "2.3.92",
   "report_format": 2,
-  "runner_version": "2.3.90",
+  "runner_version": "2.3.92",
   "status_model": 1,
   "storage_schema": 45,
-  "watcher_version": "2.3.90"
+  "watcher_version": "2.3.92"
 }

{engineering_platform-2.3.90 → engineering_platform-2.3.92}/src/engineering_platform/assets/dashboard.css

@@ -1144,9 +1144,9 @@ html[data-theme="light"] .dashboard-status-banner--provider-auth_required .provi
    the other operational banners rather than as a scrolling dashboard card. */
 .dashboard-sticky-header:has(#noProjectSelected:not([hidden])){padding-bottom:7px}.dashboard-status-banner--no-project{align-items:center;background:#163b59;border-bottom:1px solid #62bdf0;color:#e7f5ff;font:600 13px/1.45 system-ui}.dashboard-status-banner--no-project strong{color:#9bd7ff}.no-project-selected__dismiss{align-items:center;background:transparent!important;border:1px solid currentColor!important;border-radius:50%;color:inherit!important;cursor:pointer;display:inline-flex;flex:none;font:22px/1 system-ui;height:30px;justify-content:center;margin-left:auto;min-height:30px;min-width:30px;padding:0;width:30px}.no-project-selected__dismiss:hover,.no-project-selected__dismiss:focus-visible{background:#9bd7ff!important;border-color:#9bd7ff!important;color:#123a58!important}.no-project-selected__dismiss:focus-visible{box-shadow:0 0 0 4px #9bd7ff55!important;outline:2px solid #9bd7ff!important;outline-offset:2px!important}html[data-theme="light"] .dashboard-status-banner--no-project{background:#e2f3ff;color:#12466b}html[data-theme="light"] .dashboard-status-banner--no-project strong{color:#075985}html[data-theme="light"] .no-project-selected__dismiss:hover,html[data-theme="light"] .no-project-selected__dismiss:focus-visible{background:#075985!important;border-color:#075985!important;color:#fff!important}
 
-/* Managed PR evidence remains a normal link, positioned under execution
-   context so both current and historical operational context stay scannable. */
-.prompt-detail-card--pull-requests,.active-run-pull-requests{grid-column:2}.prompt-detail-pr-link{border-bottom:1px solid currentColor;color:var(--category-color);font-weight:400;text-decoration:none}.prompt-detail-pr-link:hover{background:transparent;color:var(--category-color);outline:0}.prompt-detail-pr-link:focus-visible{background:transparent;color:var(--category-color);outline:2px solid var(--category-color);outline-offset:2px}.prompt-detail-pr-metrics{color:var(--dashboard-modal-muted);display:flex;flex-wrap:wrap;font-size:12px;gap:5px 12px;margin-top:7px}.prompt-detail-pr-metric{white-space:nowrap}@media (max-width:620px){.prompt-detail-card--pull-requests,.active-run-pull-requests{grid-column:1;grid-row:auto}}
+/* Active PR evidence starts in the left column directly below the lifecycle.
+   Historical Mission details keep PR evidence in their right context column. */
+.prompt-detail-card--pull-requests{grid-column:2}.active-run-pull-requests{grid-column:1}.prompt-detail-pr-link{border-bottom:1px solid currentColor;color:var(--category-color);font-weight:400;text-decoration:none}.prompt-detail-pr-link:hover{background:transparent;color:var(--category-color);outline:0}.prompt-detail-pr-link:focus-visible{background:transparent;color:var(--category-color);outline:2px solid var(--category-color);outline-offset:2px}.prompt-detail-pr-metrics{color:var(--dashboard-modal-muted);display:flex;flex-wrap:wrap;font-size:12px;gap:5px 12px;margin-top:7px}.prompt-detail-pr-metric{white-space:nowrap}@media (max-width:620px){.prompt-detail-card--pull-requests,.active-run-pull-requests{grid-column:1;grid-row:auto}}
 
 /* Authentication is a recoverable warning, not a destructive provider failure. */
 .dashboard-status-banner--provider-auth_required .provider-readiness-banner__action{background:transparent!important;border-color:#ffd768!important;color:#fff4d6!important}.dashboard-status-banner--provider-auth_required .provider-readiness-banner__action:hover:not(:disabled),.dashboard-status-banner--provider-auth_required .provider-readiness-banner__action:focus-visible{background:#f4c34f!important;border-color:#ffd768!important;color:#2a2415!important}.dashboard-status-banner--provider-auth_required .provider-readiness-banner__action:focus-visible{box-shadow:0 0 0 4px #f4c34f88;outline-color:#ffd768}

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

@@ -119,6 +119,7 @@ from .execution_timing import complete_active_phase as _complete_active_phase
 from .execution_timing import complete_phase as _complete_phase
 from .execution_timing import start_or_resume_phase as _start_or_resume_phase
 from .execution_timing import start_phase as _start_phase
+from .execution_timing import update_active_phase_metadata as _update_active_phase_metadata
 from .managed_autonomy import (
     append_action as record_managed_action,
     append_pr_check_observation as record_managed_pr_check,
@@ -194,6 +195,20 @@ def complete_phase(root: Path, active: ActivePhase | None, **kwargs: object) ->
         )
 
 
+def update_phase_metadata(
+    root: Path, active: ActivePhase | None, metadata: dict[str, object],
+) -> None:
+    """Publish optional bounded live phase data without affecting the run."""
+    if active is None:
+        return
+    try:
+        _update_active_phase_metadata(root, active, metadata)
+    except EngineeringStorageError as error:
+        _timing_unavailable(
+            root, active.run_id, error, central_database=active.central_database,
+        )
+
+
 def complete_active_phase(root: Path, run_id: str, phase_name: str, **kwargs: object) -> bool:
     try:
         return _complete_active_phase(root, run_id, phase_name, **kwargs)
@@ -700,6 +715,7 @@ class EngineeringRunner:
         selection: ReviewerSelection,
         event: str,
         result: ReviewerResult | None = None,
+        phase: ActivePhase | None = None,
     ) -> None:
         """Publish bounded reviewer lifecycle status without granting reviewer authority."""
         self._heartbeat()
@@ -725,6 +741,18 @@ class EngineeringRunner:
                         else 0
                     )
                 break
+            update_phase_metadata(
+                self.root,
+                phase,
+                {"reviewer_agents": [
+                    {
+                        "reviewer": str(item.get("reviewer", ""))[:80],
+                        "capability": str(item.get("capability", "engineering"))[:80],
+                        "status": str(item.get("status", "selected"))[:16],
+                    }
+                    for item in self.reviewer_runtime[:12]
+                ]},
+            )
             write_live_status(self.root, state, "Capability review: " + selection.reviewer, self.reviewer_runtime)
 
     def _persist_agent_usage(self, run_id: str) -> None:
@@ -3086,6 +3114,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 +3249,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 +3303,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
@@ -3312,6 +3394,18 @@ First implementation pull-request publication gate:
             }
             for item in selections
         ]
+        update_phase_metadata(
+            self.root,
+            capability_review,
+            {"reviewer_agents": [
+                {
+                    "reviewer": str(item["reviewer"])[:80],
+                    "capability": str(item["capability"])[:80],
+                    "status": "selected",
+                }
+                for item in self.reviewer_runtime[:12]
+            ]},
+        )
         write_live_status(
             self.root,
             state
@@ -3326,13 +3420,26 @@ 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,
             objective,
             self.agent if hasattr(self.agent, "review") else None,
             progress=lambda selection, event, result: self._publish_reviewer_progress(
-                state, selection, event, result
+                state, selection, event, result, capability_review
             ),
             evidence=reviewer_evidence,
         )
@@ -3426,6 +3533,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.92}/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.90 → engineering_platform-2.3.92}/src/engineering_platform/execution_timing.py

@@ -132,6 +132,29 @@ def complete_phase(root: Path, active: ActivePhase, *, outcome: str = "COMPLETE"
         connection.close()
 
 
+def update_active_phase_metadata(
+    root: Path, active: ActivePhase, metadata: Mapping[str, object],
+) -> None:
+    """Replace bounded metadata for one exact active phase.
+
+    Live projections can change while the measured phase is active. The phase
+    identity and timing remain immutable; only its bounded presentation data is
+    replaced, and a terminal phase cannot be rewritten.
+    """
+    encoded = _metadata(metadata)
+    connection = _connection(root, active.central_database)
+    try:
+        changed = connection.execute(
+            """UPDATE execution_phase_spans SET metadata=?
+                 WHERE phase_id=? AND run_id=? AND outcome='ACTIVE'""",
+            (encoded, active.phase_id, active.run_id),
+        ).rowcount
+        if changed != 1:
+            raise EngineeringStorageError("Execution phase is not active.")
+    finally:
+        connection.close()
+
+
 def start_or_resume_phase(root: Path, run_id: str, phase_name: str, **kwargs: object) -> ActivePhase:
     """Start one envelope or resume its observed active database boundary.
 

engineering_platform-2.3.92/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.92}/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.92}/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.92}/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.92"
 MANIFEST_FIELDS = frozenset(
     {
         "platform_version",

{engineering_platform-2.3.90 → engineering_platform-2.3.92}/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)