feat(engine)!: ship-check Gate 5 re-executes via oracle; remove self-grantable override

Gate 5 was a FAKABLE deterministic grep over .atlas-ai/evidence/ that SILENTLY
PASSED when no evidence existed, and was bypassable via the self-grantable
--override SHIP_CHECK_OVERRIDE_ADMIN token. Both are removed.

skel/ship-check.py (standalone, stdlib-only — shells `atlas oracle grade`):
- Delete OVERRIDE_TOKEN, log_override, --override arg, override_active, and the
  [OVERRIDE] suffix. run_all_gates loses the override_active param.
- Replace gate_exit_codes with gate_oracle(repo_root, tasks, head_commit): for
  every DONE task, re-grade its CDD card via the oracle CLI. FAIL-CLOSED on a
  missing card, a card with no grading block, a CLI crash, unparseable output,
  or any verdict != "PASS". Add _head_commit() (git rev-parse HEAD; fail-closed
  to "UNKNOWN").
- Gates 1-4 and --dry-run/--cwd unchanged. Stdout contract unchanged: exactly
  "SHIP_CHECK_OK" on success, nothing on failure.

tests/core/test_ship_check_oracle.py (new): oracle PASS ships; oracle FAIL
blocks; non-JSON fail-closed; missing-card fail-closed; override token removed;
Gates 1-4 regression.

tests/core/test_ship_check.py (updated to new contract): green-tree CDD cards
carry a grading block + a fake ATLAS_ORACLE_CMD; the old Gate-5 grep + override
test replaced with an oracle-FAIL-blocks + override-is-gone test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: claude

skel/ship-check.py

@@ -4,6 +4,11 @@
 Emits SHIP_CHECK_OK to stdout ONLY when all gates pass. Called by execute-task
 at termination AND by Step 9 (--dry-run) as a per-task predicate.
 
+Standalone: this file ships into user projects as `.atlas-ai/ship-check.py`. It
+imports ONLY the stdlib and MUST stay that way (no `import prd_taskmaster` — that
+package is not importable in a user project). The oracle gate therefore shells
+the `atlas oracle grade` CLI directly via subprocess.
+
 Gate logic (grounded against actual pipeline.json / tasks.json schemas
 observed 2026-06-04 in ai-human-tasker):
 
@@ -27,36 +32,37 @@
     skel checked .atlas-ai/ralph-loop-prompt.md — wrong path and irrelevant
     after /goal migration.
 
-  Gate 5 (HARD) — No non-zero "Exit status N" line in any .atlas-ai/evidence/
-    file. This is the convergent must-do from the 2026-06-04 forensic audit
-    (T12 marked DONE while pnpm test exited 1 with 11 failing tests).
-    Override only via SHIP_CHECK_OVERRIDE_ADMIN token; overrides are logged
-    to .atlas-ai/state/execute-log.jsonl as an audit record.
+  Gate 5 (HARD, ORACLE) — Each DONE task is RE-GRADED by the atlas oracle.
+    The submitter's own .atlas-ai/evidence/ is NOT trusted; the oracle
+    re-executes the CDD card's grading against HEAD and writes its own
+    evidence/ledger. This replaces the fakable "no non-zero Exit status N in
+    evidence" grep — which silently PASSED when no evidence existed and had a
+    self-grantable bypass token. Both the silent-pass loophole and the bypass
+    token are GONE. The gate is FAIL-CLOSED: a missing card, a card with no
+    grading block, a CLI crash, unparseable output, or any verdict other than
+    "PASS" all BLOCK the ship.
 
 Interface:
   python3 .atlas-ai/ship-check.py                              # standard gate
   python3 .atlas-ai/ship-check.py --dry-run                    # always exit 0; report on stderr
-  python3 .atlas-ai/ship-check.py --override SHIP_CHECK_OVERRIDE_ADMIN  # bypass Gate 5
   python3 .atlas-ai/ship-check.py --cwd /path/to/project       # explicit project root
 
 Exit codes:
-  0 — SHIP_CHECK_OK (stdout: exactly "SHIP_CHECK_OK\n", with " [OVERRIDE]" suffix if applicable)
+  0 — SHIP_CHECK_OK (stdout: exactly "SHIP_CHECK_OK\n")
   1 — gate failures (stderr only; nothing on stdout — log watchers must not see partial matches)
-  2 — script error (IO, JSON parse, bad token)
+  2 — script error (IO, JSON parse)
 """
 from __future__ import annotations
 
 import argparse
 import json
-import re
+import os
+import shlex
+import subprocess
 import sys
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import List, Tuple
 
-OVERRIDE_TOKEN = "SHIP_CHECK_OVERRIDE_ADMIN"
-EXIT_STATUS_RE = re.compile(r"\bExit status\s+(\d+)\b", re.IGNORECASE)
-
 
 def gate_pipeline(atlas: Path) -> Tuple[bool, List[str]]:
     pf = atlas / "state" / "pipeline.json"
@@ -138,46 +144,101 @@ def gate_plan(repo_root: Path) -> Tuple[bool, List[str]]:
     return False, ["no plan file at .taskmaster/docs/plan.md or docs/superpowers/plans/*.md"]
 
 
-def gate_exit_codes(atlas: Path) -> Tuple[bool, List[str]]:
+def _oracle_cmd() -> List[str]:
+    """Configurable oracle CLI invocation. Default: the 'atlas' binary on PATH.
+
+    Set ATLAS_ORACLE_CMD (shell-split) to change it, e.g.:
+        ATLAS_ORACLE_CMD="node /path/to/atlas-protocol/apps/cli/dist/index.js"
+    """
+    raw = os.environ.get("ATLAS_ORACLE_CMD")
+    if raw:
+        return shlex.split(raw)
+    return ["atlas"]
+
+
+def _head_commit(repo_root: Path) -> str:
+    """HEAD sha via `git rev-parse HEAD`. FAIL-CLOSED: any failure returns the
+    sentinel "UNKNOWN" so the oracle mismatches the working tree and blocks."""
+    try:
+        proc = subprocess.run(
+            ["git", "-C", str(repo_root), "rev-parse", "HEAD"],
+            capture_output=True, text=True, timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "UNKNOWN"
+    if proc.returncode != 0:
+        return "UNKNOWN"
+    sha = (proc.stdout or "").strip()
+    return sha or "UNKNOWN"
+
+
+def gate_oracle(repo_root: Path, tasks: list, head_commit: str) -> Tuple[bool, List[str]]:
+    """Re-grade every DONE task via the atlas oracle CLI. FAIL-CLOSED.
+
+    For each done task: the CDD card must exist and carry a 'grading' block,
+    and the oracle must return verdict=="PASS". Anything else — missing card,
+    no grading block, CLI crash, unparseable output, a non-PASS verdict —
+    appends a failure. The submitter's evidence is NOT read here; the oracle
+    re-executes the grading and writes its own evidence/ledger.
+    """
     failures: List[str] = []
-    evidence_dir = atlas / "evidence"
-    if not evidence_dir.exists():
-        # Gate 3 (CDD) catches missing evidence; this gate is silent when no evidence exists
-        return True, []
-    for f in evidence_dir.rglob("*"):
-        if not f.is_file():
+    atlas = repo_root / ".atlas-ai"
+    held = atlas / "held-out"
+    evidence = atlas / "evidence"
+    ledger = atlas / "ledger"
+    cmd_base = _oracle_cmd()
+
+    for t in tasks:
+        if t.get("status") != "done":
+            continue
+        tid = t.get("id")
+        card_path = atlas / "cdd" / f"task-{tid}.json"
+        if not card_path.exists():
+            failures.append(f"task {tid}: no CDD card to grade")
             continue
         try:
-            text = f.read_text(errors="ignore")
-        except OSError:
+            card = json.loads(card_path.read_text())
+        except (OSError, json.JSONDecodeError) as exc:
+            failures.append(f"task {tid}: cannot read CDD card ({exc})")
+            continue
+        if "grading" not in card:
+            failures.append(f"task {tid}: CDD card has no grading block")
+            continue
+
+        cmd = cmd_base + [
+            "oracle", "grade",
+            "--repo", str(repo_root),
+            "--commit", head_commit,
+            "--card", str(card_path),
+            "--held", str(held),
+            "--evidence", str(evidence),
+            "--ledger", str(ledger),
+        ]
+        try:
+            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+        except (OSError, subprocess.SubprocessError) as exc:
+            failures.append(f"task {tid}: oracle CLI invocation failed ({exc})")
+            continue
+
+        try:
+            parsed = json.loads(proc.stdout)
+        except (json.JSONDecodeError, TypeError):
+            failures.append(f"task {tid}: oracle produced no parseable JSON verdict (rc={proc.returncode})")
             continue
-        for match in EXIT_STATUS_RE.finditer(text):
-            try:
-                code = int(match.group(1))
-            except (ValueError, IndexError):
-                continue
-            if code != 0:
-                rel = f.relative_to(atlas.parent) if atlas.parent in f.parents else f
-                failures.append(f"non-zero exit in {rel}: Exit status {code}")
-                break  # one report per file is enough
-    return len(failures) == 0, failures
 
+        verdict = parsed.get("verdict") if isinstance(parsed, dict) else None
+        if verdict not in ("PASS", "FAIL"):
+            failures.append(f"task {tid}: oracle verdict missing/invalid ({verdict!r})")
+            continue
+        if verdict == "FAIL":
+            failures.append(f"task {tid}: oracle verdict FAIL")
+            continue
+        # verdict == "PASS" — the only path that does NOT append a failure.
 
-def log_override(atlas: Path, message: str) -> None:
-    log = atlas / "state" / "execute-log.jsonl"
-    log.parent.mkdir(parents=True, exist_ok=True)
-    entry = {
-        "iteration": "OVERRIDE",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "task_id": "SHIP_CHECK",
-        "event": "override_invoked",
-        "message": message,
-    }
-    with log.open("a") as fp:
-        fp.write(json.dumps(entry) + "\n")
+    return len(failures) == 0, failures
 
 
-def run_all_gates(repo_root: Path, override_active: bool) -> Tuple[bool, List[str]]:
+def run_all_gates(repo_root: Path) -> Tuple[bool, List[str]]:
     failures: List[str] = []
     atlas = repo_root / ".atlas-ai"
 
@@ -191,38 +252,28 @@ def run_all_gates(repo_root: Path, override_active: bool) -> Tuple[bool, List[st
         _, f3 = gate_cdd(atlas, tasks)
         failures.extend(f3)
 
+        head = _head_commit(repo_root)
+        _, f5 = gate_oracle(repo_root, tasks, head)
+        failures.extend(f5)
+
     _, f4 = gate_plan(repo_root)
     failures.extend(f4)
 
-    ok5, f5 = gate_exit_codes(atlas)
-    if not ok5:
-        if override_active:
-            log_override(atlas, f"Gate 5 bypassed: {'; '.join(f5[:3])}{' ...' if len(f5) > 3 else ''}")
-            # Override accepts the failures; no append to global failures list
-        else:
-            failures.extend(f5)
-
     return len(failures) == 0, failures
 
 
 def main() -> int:
     parser = argparse.ArgumentParser(description="Deterministic ship-check for prd-taskmaster pipelines.")
     parser.add_argument("--dry-run", action="store_true",
                         help="Run all gates but always exit 0. Report goes to stderr. Used by execute-task Step 9 as a per-task predicate.")
-    parser.add_argument("--override", type=str, default=None,
-                        help=f"Bypass Gate 5 (exit codes) if value equals {OVERRIDE_TOKEN}. Logged to execute-log.jsonl.")
     parser.add_argument("--cwd", type=str, default=None,
                         help="Project root (defaults to current working directory).")
     args = parser.parse_args()
 
     repo_root = Path(args.cwd).resolve() if args.cwd else Path.cwd()
-    override_active = args.override == OVERRIDE_TOKEN
-    if args.override is not None and not override_active:
-        print("FAIL: --override value does not match expected token", file=sys.stderr)
-        return 2
 
     try:
-        ok, failures = run_all_gates(repo_root, override_active=override_active)
+        ok, failures = run_all_gates(repo_root)
     except Exception as exc:  # noqa: BLE001 — top-level guard
         print(f"FAIL: ship-check script error: {exc!r}", file=sys.stderr)
         return 2
@@ -237,8 +288,7 @@ def main() -> int:
         return 0
 
     if ok:
-        suffix = " [OVERRIDE]" if override_active else ""
-        print(f"SHIP_CHECK_OK{suffix}")
+        print("SHIP_CHECK_OK")
         return 0
 
     for f in failures:

tests/core/test_ship_check.py

@@ -12,14 +12,26 @@
   Gate 3 — for each task id, a CDD card at .atlas-ai/cdd/task-<id>.json (or a
            combined card whose filename contains the id).
   Gate 4 — plan at .taskmaster/docs/plan.md OR docs/superpowers/plans/*.md.
-  Gate 5 (HARD) — no non-zero "Exit status N" in any .atlas-ai/evidence/ file.
-           Bypass via --override SHIP_CHECK_OVERRIDE_ADMIN.
-  Success → stdout exactly "SHIP_CHECK_OK\n" (+ " [OVERRIDE]"), exit 0.
+  Gate 5 (HARD, ORACLE) — every DONE task is RE-GRADED by the atlas oracle CLI
+           (shelled out; configurable via ATLAS_ORACLE_CMD). FAIL-CLOSED: a
+           missing card, a card with no grading block, a CLI crash, unparseable
+           output, or any non-PASS verdict BLOCKS the ship. The old fakable
+           "no non-zero Exit status N in evidence" grep and the self-grantable
+           --override SHIP_CHECK_OVERRIDE_ADMIN token are BOTH GONE (see the
+           dedicated coverage in test_ship_check_oracle.py).
+  Success → stdout exactly "SHIP_CHECK_OK\n", exit 0.
   Failure → nothing on stdout, FAIL detail on stderr, exit 1.
+
+NOTE: these tests drive the script as a real subprocess, so the oracle gate is
+satisfied by a real fake-oracle command (a tiny executable shell script) wired
+through ATLAS_ORACLE_CMD. Pure-monkeypatch oracle coverage lives in
+test_ship_check_oracle.py.
 """
 from __future__ import annotations
 
 import json
+import os
+import stat
 import subprocess
 from pathlib import Path
 
@@ -31,18 +43,41 @@
 SHIP_CHECK = REPO_ROOT / "skel" / "ship-check.py"
 
 
-def _run(cwd: Path, *extra: str) -> subprocess.CompletedProcess[str]:
+def _fake_oracle(tmp_path: Path, verdict: str = "PASS") -> str:
+    """Write an executable fake `atlas` that emits {"verdict": <verdict>} for an
+    `oracle grade` invocation. Return an ATLAS_ORACLE_CMD value pointing at it."""
+    script = tmp_path / "fake_atlas.sh"
+    script.write_text(
+        "#!/bin/sh\n"
+        'for a in "$@"; do\n'
+        '  if [ "$a" = "grade" ]; then\n'
+        f'    printf \'{{"verdict":"{verdict}"}}\'\n'
+        "    exit 0\n"
+        "  fi\n"
+        "done\n"
+        "exit 0\n"
+    )
+    script.chmod(script.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    return f"sh {script}"
+
+
+def _run(cwd: Path, *extra: str, oracle_cmd: str | None = None) -> subprocess.CompletedProcess[str]:
+    env = dict(os.environ)
+    if oracle_cmd is not None:
+        env["ATLAS_ORACLE_CMD"] = oracle_cmd
     return subprocess.run(
         ["python3", str(SHIP_CHECK), *extra],
         cwd=str(cwd),
         capture_output=True,
         text=True,
         check=False,
+        env=env,
     )
 
 
 def _green(tmp_path: Path) -> None:
-    """Build an all-gates-green project tree under tmp_path."""
+    """Build an all-gates-green project tree under tmp_path. CDD cards carry a
+    `grading` block so the oracle gate can re-grade them."""
     atlas = tmp_path / ".atlas-ai"
     (atlas / "state").mkdir(parents=True)
     (atlas / "state" / "pipeline.json").write_text(
@@ -64,8 +99,9 @@ def _green(tmp_path: Path) -> None:
     )
     cdd = atlas / "cdd"
     cdd.mkdir(parents=True)
-    (cdd / "task-1.json").write_text(json.dumps({"id": 1}))
-    (cdd / "task-2.json").write_text(json.dumps({"id": 2}))
+    grading = {"grading": {"command": ["sh", "grade.sh"]}}
+    (cdd / "task-1.json").write_text(json.dumps({"id": 1, **grading}))
+    (cdd / "task-2.json").write_text(json.dumps({"id": 2, **grading}))
     docs = tmp_path / ".taskmaster" / "docs"
     docs.mkdir(parents=True)
     (docs / "plan.md").write_text("# Plan\n")
@@ -80,7 +116,7 @@ def test_ship_check_fails_on_empty_state(tmp_path: Path) -> None:
 
 def test_ship_check_passes_on_all_gates_green(tmp_path: Path) -> None:
     _green(tmp_path)
-    r = _run(tmp_path)
+    r = _run(tmp_path, oracle_cmd=_fake_oracle(tmp_path, "PASS"))
     assert r.returncode == 0, f"stderr={r.stderr!r} stdout={r.stdout!r}"
     assert "SHIP_CHECK_OK" in r.stdout
 
@@ -118,25 +154,27 @@ def test_ship_check_fails_when_done_task_has_no_cdd_card(tmp_path: Path) -> None
     assert "task 2: no CDD card" in r.stderr
 
 
-def test_ship_check_gate5_blocks_on_nonzero_exit_and_override_passes(tmp_path: Path) -> None:
-    """Gate 5 (HARD): a non-zero 'Exit status N' in evidence blocks; the
-    override token bypasses it."""
+def test_ship_check_gate5_oracle_fail_blocks_and_override_is_gone(tmp_path: Path) -> None:
+    """Gate 5 (HARD, ORACLE): an oracle FAIL verdict blocks the ship, and the
+    old self-grantable --override token no longer exists (argparse rejects it)."""
     _green(tmp_path)
-    evidence = tmp_path / ".atlas-ai" / "evidence"
-    evidence.mkdir(parents=True)
-    (evidence / "run.log").write_text("pnpm test\nExit status 1\n")
 
-    # Without override → blocked.
-    r = _run(tmp_path)
+    # An oracle FAIL verdict → blocked, nothing on stdout.
+    r = _run(tmp_path, oracle_cmd=_fake_oracle(tmp_path, "FAIL"))
     assert r.returncode != 0
     assert "SHIP_CHECK_OK" not in r.stdout
-    assert "Exit status 1" in r.stderr
-
-    # With the override token → passes, OVERRIDE suffix on stdout.
-    r2 = _run(tmp_path, "--override", "SHIP_CHECK_OVERRIDE_ADMIN")
-    assert r2.returncode == 0, f"stderr={r2.stderr!r} stdout={r2.stdout!r}"
-    assert "SHIP_CHECK_OK" in r2.stdout
-    assert "[OVERRIDE]" in r2.stdout
+    assert "oracle verdict FAIL" in r.stderr
+
+    # The override token is GONE: argparse rejects the unknown flag (exit 2)
+    # and never emits SHIP_CHECK_OK — there is no bypass path.
+    r2 = _run(
+        tmp_path,
+        "--override",
+        "SHIP_CHECK_OVERRIDE_ADMIN",
+        oracle_cmd=_fake_oracle(tmp_path, "PASS"),
+    )
+    assert r2.returncode == 2
+    assert "SHIP_CHECK_OK" not in r2.stdout
 
 
 # ─── Python API agreement (prd_taskmaster.shipcheck.run_ship_check) ──────────
@@ -171,6 +209,6 @@ def test_ship_check_passes_with_flat_tasks_format(tmp_path):
     (tmp_path / ".taskmaster" / "tasks" / "tasks.json").write_text(json.dumps(
         {"tasks": [{"id": 1, "status": "done"}, {"id": 2, "status": "done"}]}
     ))
-    r = _run(tmp_path)
+    r = _run(tmp_path, oracle_cmd=_fake_oracle(tmp_path, "PASS"))
     assert r.returncode == 0, f"stderr={r.stderr!r}"
     assert "SHIP_CHECK_OK" in r.stdout