fix(event-driven): resolve short SHAs to full 40-char before authority read — 12-char prefix silently failed _fetch_runs equality (962e351 root cause)

chore(deps): apply regenerated lock (multidict 6.9.0)
chore(deps): re-lock requirements-ci.txt (upstream multidict 6.9.0) — dep-lock gate
2026-09-18 19:14:23 +01:00 · 2026-09-18 17:18:30 +01:00 · 2026-09-18 17:17:52 +01:00 · 2026-09-18 17:09:40 +01:00 · 2026-09-18 13:25:21 +01:00 · 2026-09-18 12:57:52 +01:00
21 changed files with 1779 additions and 41 deletions
@@ -1,6 +1,6 @@
 # Rune

-**Current release: v0.83.3**
+**Current release: v0.85.6**

 **Rune is a persistent personal agent designed to accumulate experience, develop reusable competence, and remain recognisably the same agent even when its underlying foundation model changes.**

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "rune"
-version = "0.83.3"
+version = "0.85.6"
 description = "Rune — a stateful coding assistant with persistent memory, orchestration, and TUI"
 requires-python = ">=3.10"

@@ -1,5 +1,5 @@
 # This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml -o /tmp/regen-req.txt --extra dev --extra memory --python-version 3.11
+#    uv pip compile pyproject.toml -o /tmp/req3.txt --extra dev --extra memory --python-version 3.11
 aiohappyeyeballs==2.7.1
    # via aiohttp
 aiohttp==3.14.3
@@ -56,7 +56,7 @@ mdit-py-plugins==0.6.1
    # via textual
 mdurl==0.1.2
    # via markdown-it-py
-multidict==6.8.0
+multidict==6.9.0
    # via
    #   aiohttp
    #   yarl
@@ -64,7 +64,7 @@ nodeenv==1.10.0
    # via pyright
 packaging==26.3
    # via pytest
-platformdirs==4.11.9
+platformdirs==4.11.10
    # via textual
 pluggy==1.6.0
    # via
@@ -0,0 +1,404 @@
+"""await_intent.py — ASYNC CORRECTIVE PATCH: intent normalization at the
+execution boundary.
+
+PRINCIPLE: MODEL OUTPUT = INTENT. RUNE CONTROLLER = EXECUTION SEMANTICS.
+
+The model may express continuation intent in any quality — `await_operation
+(deadline_secs=1200)`, `await-operation [op_type=master_ci, sha=X]`,
+"sleep 300 then check CI", "poll until done". When a matching
+PendingOperation exists (or the deterministic resolver can derive the
+operation truth from git/Gitea state), the controller executes the
+CANONICAL continuation and discards model-supplied scheduling policy.
+
+Authority provenance for timing:
+  USER_EXPLICIT / EXTERNAL_CONTRACT / TEST_HARNESS /
+  GOVERNED_OPERATION_POLICY  -> authoritative, retained
+  MODEL_INVENTED             -> non-authoritative, ignored
+
+This module owns NO storage: it reads the existing W/R wait store
+(rune.event_wait) and git/Gitea state. The canonical continuation remains
+scripts/ci_event_wait.py run() (the T21.5 single-logical-await).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPT_DIR))
+_REPO_SRC = str(_SCRIPT_DIR.parent / "src")
+if _REPO_SRC not in sys.path:
+    sys.path.insert(0, _REPO_SRC)
+
+WR_BRIDGE = Path(os.environ.get("RUNE_WR_ROOT", "/mnt/workdrive/wr-bridge"))
+REPO = Path("/mnt/workdrive/issue161-harness")
+GIT_TIMEOUT = 10
+
+# Default policy deadline per operation type — GOVERNED_OPERATION_POLICY.
+# The model's numbers never become policy; these are the controller's.
+POLICY_DEADLINES = {
+    "branch_ci": 1800,
+    "pull_request_checks": 1800,
+    "master_ci": 1800,
+    "deploy": 900,
+    "release": 900,
+}
+
+VALID_OP_TYPES = ("branch_ci", "pull_request_checks", "master_ci",
+                  "deploy", "release")
+
+
+# ── timing provenance ───────────────────────────────────────────────────────
+
+def classify_timing_provenance(model_deadline: Any = None,
+                               user_deadline: Any = None,
+                               contract_deadline: Any = None) -> tuple[int, str]:
+    """Resolve the effective deadline + its provenance.
+
+    Authority order: USER_EXPLICIT > EXTERNAL_CONTRACT > TEST_HARNESS >
+    GOVERNED_OPERATION_POLICY. MODEL_INVENTED values are recorded but
+    NEVER used as policy.
+    """
+    if model_deadline is not None:
+        try:
+            model_deadline = int(model_deadline)
+        except (TypeError, ValueError):
+            model_deadline = None
+    if user_deadline is not None:
+        return int(user_deadline), "USER_EXPLICIT"
+    if contract_deadline is not None:
+        return int(contract_deadline), "EXTERNAL_CONTRACT"
+    return (model_deadline or 0), "MODEL_INVENTED"  # caller discards this
+
+
+# ── PendingOperation lookup over the existing W/R wait store ────────────────
+
+def _load_wait_records() -> list[dict]:
+    """All durable wait records from the bridge store (read-only)."""
+    out = []
+    waits = WR_BRIDGE / "waits"
+    if not waits.is_dir():
+        return out
+    for f in sorted(waits.glob("*.json")):
+        try:
+            rec = json.loads(f.read_text())
+            rec["_file"] = f.name
+            out.append(rec)
+        except (OSError, ValueError):
+            continue
+    return out
+
+
+def _rec_operation_id(rec: dict) -> str:
+    return str((rec.get("ext") or {}).get("operation_id")
+               or rec.get("operation_id") or "")
+
+
+def _rec_sha(rec: dict) -> str:
+    return str(rec.get("sha") or "")
+
+
+def pending_operations(sha: str = "", op_type: str = "") -> list[dict]:
+    """Pending (non-terminal) operations, optionally filtered."""
+    terminal = {"COMPLETED", "FAILED", "CLOSED", "CANCELLED", "EXPIRED"}
+    out = []
+    for rec in _load_wait_records():
+        status = str(rec.get("status", "")).upper()
+        if status in terminal:
+            continue
+        if sha and _rec_sha(rec) != sha:
+            continue
+        out.append(rec)
+    return out
+
+
+def find_op_type_for_sha(sha: str) -> str | None:
+    """The op_type a prior canonical wait already recorded for this SHA
+    (objective text embeds the type: 'event-driven {op_type} qualification')."""
+    for rec in _load_wait_records():
+        if _rec_sha(rec) != sha:
+            continue
+        obj = str(rec.get("continuation", {}).get("objective", ""))
+        m = re.search(r"event-driven (\w+) qualification", obj)
+        if m and m.group(1) in VALID_OP_TYPES:
+            return m.group(1)
+    return None
+
+
+# ── deterministic op_type derivation from repo/Gitea truth ─────────────────
+
+def _git(*args: str) -> str:
+    try:
+        r = subprocess.run(["git", "-C", str(REPO), *args],
+                           capture_output=True, text=True, timeout=GIT_TIMEOUT)
+        return r.stdout.strip()
+    except (OSError, subprocess.TimeoutExpired):
+        return ""
+
+
+def sha_branch(sha: str) -> str:
+    """Branch(es) containing this commit in the local repo."""
+    return _git("branch", "--all", "--contains", sha)
+
+
+def sha_on_master(sha: str) -> bool:
+    out = _git("branch", "--contains", sha)
+    return any(l.strip().endswith("master") or l.strip() == "master"
+               for l in out.splitlines())
+
+
+def open_pr_for_sha(sha: str) -> int | None:
+    """Is there an OPEN PR whose head SHA is this one? (Gitea API, read-only.)"""
+    try:
+        sys.path.insert(0, str(_SCRIPT_DIR))
+        import gitea_auth  # noqa: E402
+        st, prs = gitea_auth.api("/pulls?state=open&limit=50")
+        if st != 200:
+            return None
+        for p in prs:
+            hs = str(p.get("head") or {}).get("sha") if isinstance(
+                p.get("head"), dict) else None
+            if hs and str(hs).startswith(sha[:12]):
+                return int(p.get("number"))
+    except Exception:  # noqa: BLE001 — resolver must never crash the tool
+        return None
+    return None
+
+
+def derive_op_type(sha: str) -> tuple[str, str]:
+    """Deterministically derive the canonical op_type for a SHA.
+
+    Returns (op_type, evidence). Order (A-patch §2 amendment):
+      1. POST-PATCH normalized record (ext.intent_normalized=true) — true
+         stored operation truth, wins outright;
+      2. open PR for the sha -> pull_request_checks;
+      3. sha ancestor of master -> master_ci;
+      4. sha on a feature branch -> branch_ci;
+      5. legacy (pre-patch) records only CONFIRM, never override — they
+         were created from model-supplied defaults and cannot be trusted.
+    Never trusts model input.
+    """
+    for rec in _load_wait_records():
+        if _rec_sha(rec) != sha:
+            continue
+        if (rec.get("ext") or {}).get("intent_normalized"):
+            obj = str(rec.get("continuation", {}).get("objective", ""))
+            m = re.search(r"event-driven (\w+) qualification", obj)
+            if m and m.group(1) in VALID_OP_TYPES:
+                return m.group(1), "normalized_record:" + m.group(1)
+    pr = open_pr_for_sha(sha)
+    if pr:
+        return "pull_request_checks", f"open_pr:#{pr}"
+    if sha_on_master(sha):
+        return "master_ci", "commit_ancestor_of_master"
+    return "branch_ci", "commit_on_feature_branch"
+
+
+# ── intent normalization ────────────────────────────────────────────────────
+
+def normalize_action(action: dict, *,
+                     model_deadline: Any = None,
+                     user_deadline: Any = None,
+                     contract_deadline: Any = None) -> dict:
+    """Normalize a model continuation action into the canonical continuation.
+
+    action: {kind: await_operation|sleep_poll|check_status|unknown,
+             sha?: str, operation_id?: str, op_type?: str, raw?: str}
+    Returns:
+      {normalized: bool, action: "ContinuePendingOperation", operation_id,
+       op_type, authority, deadline_secs, deadline_provenance,
+       model_deadline_ignored, model_op_type_ignored, evidence}
+    or {normalized: False, reason: ...} / {normalized: "AMBIGUOUS", candidates}
+    """
+    sha = str(action.get("sha") or "")
+    op_id = str(action.get("operation_id") or "")
+    model_op_type = action.get("op_type")
+    model_deadline_ignored = model_deadline is not None
+    model_op_type_ignored = model_op_type is not None
+
+    # 1. explicit operation_id wins
+    if op_id:
+        from rune import event_wait as ew  # noqa: E402
+        rec = ew.operation_wait(op_id)
+        if rec is None:
+            return {"normalized": False,
+                    "reason": f"operation_id {op_id} has no wait record"}
+        return _canonical_from_record(rec, model_deadline_ignored,
+                                      model_op_type_ignored, "explicit_id",
+                                      user_deadline, contract_deadline)
+
+    # 2. resolve by sha / active operation.
+    # H-PATCH H2/H3: the model sha is a HINT. If it doesn't resolve but
+    # unambiguous pending operations exist, the STORED target wins — a
+    # mistyped model sha must never create a ghost operation (the A-patch
+    # live failure: a typo'd sha derived branch_ci for a nonexistent commit
+    # and parked a wait on a ghost).
+    candidates = pending_operations(sha=sha)
+    if len(candidates) > 1 and not sha:
+        return {"normalized": "AMBIGUOUS",
+                "candidates": [_rec_operation_id(c) for c in candidates],
+                "reason": "multiple pending operations, no target"}
+    if len(candidates) == 1:
+        rec = candidates[0]
+        stored_sha = _rec_sha(rec)
+        norm = _canonical_from_record(rec, model_deadline_ignored,
+                                      model_op_type_ignored, "pending_match",
+                                      user_deadline, contract_deadline)
+        if sha and stored_sha and sha != stored_sha:
+            norm["model_sha_mismatch"] = {
+                "model_sha": sha, "stored_sha": stored_sha,
+                "resolution": "stored_target_used"}
+        return norm
+    # model sha unresolved: any unambiguous pending op at all? then the
+    # model probably mistyped the sha — use the stored target, log it.
+    all_pending = pending_operations()
+    if len(all_pending) == 1 and sha:
+        rec = all_pending[0]
+        stored_sha = _rec_sha(rec)
+        norm = _canonical_from_record(rec, model_deadline_ignored,
+                                      model_op_type_ignored,
+                                      "unresolved_sha_single_pending",
+                                      user_deadline, contract_deadline)
+        norm["model_sha_mismatch"] = {
+            "model_sha": sha, "stored_sha": stored_sha,
+            "resolution": "stored_target_used"}
+        return norm
+
+    # 3. no stored record: derive truth deterministically
+    if not sha:
+        return {"normalized": False,
+                "reason": "no pending operation and no sha to resolve"}
+    op_type, evidence = derive_op_type(sha)
+    return {
+        "normalized": True,
+        "action": "ContinuePendingOperation",
+        "operation_id": f"ci-{sha}",
+        "op_type": op_type,
+        "authority": "ci_runs" if op_type in ("branch_ci",
+                                              "pull_request_checks")
+                     else "deploy_qualify",
+        "deadline_secs": POLICY_DEADLINES[op_type],
+        "deadline_provenance": "GOVERNED_OPERATION_POLICY",
+        "model_deadline_ignored": model_deadline_ignored,
+        "model_op_type_ignored": model_op_type_ignored,
+        "evidence": evidence,
+    }
+
+
+def _canonical_from_record(rec: dict, model_deadline_ignored: bool,
+                           model_op_type_ignored: bool, how: str,
+                           user_deadline: Any, contract_deadline: Any) -> dict:
+    op_id = _rec_operation_id(rec)
+    obj = str(rec.get("continuation", {}).get("objective", ""))
+    m = re.search(r"event-driven (\w+) qualification", obj)
+    recorded = m.group(1) if (m and m.group(1) in VALID_OP_TYPES) else None
+    rec_sha = _rec_sha(rec)
+    if (rec.get("ext") or {}).get("intent_normalized") or how == "explicit_id":
+        # normalized record or explicit id: stored truth wins
+        op_type = recorded or "master_ci"
+    else:
+        # legacy record: git/Gitea derivation outranks the model-era default
+        op_type, _ev = derive_op_type(rec_sha) if rec_sha else \
+            (recorded or "master_ci", "no_sha")
+    deadline, prov = classify_timing_provenance(
+        user_deadline=user_deadline, contract_deadline=contract_deadline)
+    if prov == "MODEL_INVENTED" or not deadline:
+        deadline = POLICY_DEADLINES.get(op_type, 1800)
+        prov = "GOVERNED_OPERATION_POLICY"
+    return {
+        "normalized": True,
+        "action": "ContinuePendingOperation",
+        "operation_id": op_id,
+        "op_type": op_type,
+        "authority": "ci_runs" if op_type in ("branch_ci",
+                                              "pull_request_checks")
+                     else "deploy_qualify",
+        "deadline_secs": deadline,
+        "deadline_provenance": prov,
+        "model_deadline_ignored": model_deadline_ignored,
+        "model_op_type_ignored": model_op_type_ignored,
+        "matched_by": how,
+    }
+
+
+def normalize_bash(command: str, *, sha_hint: str = "") -> dict | None:
+    """Recognize sleep/check/poll intent aimed at a known pending operation.
+
+    Returns a normalization record if the command's semantic intent is
+    continuation of a known external operation; None if the command is
+    legitimate local timing (short sync, user delay, backoff) with no
+    pending operation to continue. NEVER returns an executed sleep.
+    """
+    if not command:
+        return None
+    cmd = command.strip()
+    # long sleep + (status-check language or an explicit sha hint)
+    sleep_m = re.search(r"\bsleep\s+(\d{2,5})\b", cmd)
+    if not sleep_m:
+        return None
+    secs = int(sleep_m.group(1))
+    check_intent = bool(re.search(
+        r"\b(ci|deploy|release|status|check|poll|pipeline|run)\b", cmd,
+        re.IGNORECASE))
+    sha = sha_hint or ""
+    m = re.search(r"\b([0-9a-f]{40}|[0-9a-f]{12})\b", cmd)
+    if m:
+        sha = m.group(1)
+    if not check_intent and not sha:
+        return None  # plain sleep, no continuation intent
+    cands = pending_operations(sha=sha) if sha else pending_operations()
+    if not cands and not sha:
+        return None
+    if len(cands) > 1:
+        return {"normalized": "AMBIGUOUS",
+                "candidates": [_rec_operation_id(c) for c in cands],
+                "raw_command_kind": "sleep_poll"}
+    rec = cands[0] if cands else None
+    if rec is not None:
+        norm = _canonical_from_record(rec, True, False, "sleep_poll_intent",
+                                      None, None)
+        norm["sha_for_wait"] = _rec_sha(rec)
+    elif sha:
+        op_type, evidence = derive_op_type(sha)
+        norm = {
+            "normalized": True, "action": "ContinuePendingOperation",
+            "operation_id": f"ci-{sha}", "op_type": op_type,
+            "authority": "ci_runs" if op_type in ("branch_ci",
+                                                  "pull_request_checks")
+                         else "deploy_qualify",
+            "deadline_secs": POLICY_DEADLINES[op_type],
+            "deadline_provenance": "GOVERNED_OPERATION_POLICY",
+            "model_deadline_ignored": True, "model_op_type_ignored": False,
+            "evidence": evidence, "sha_for_wait": sha,
+        }
+    else:
+        return None
+    norm["raw_command_kind"] = "sleep_poll"
+    norm["raw_sleep_seconds_suppressed"] = secs
+    return norm
+
+
+def emit_normalized_record(record: dict) -> None:
+    """Compact structured observability — one JSONL line per normalization.
+    No payloads, no secrets."""
+    try:
+        log = _SCRIPT_DIR.parent / "store" / "await_intent_log.jsonl"
+        log.parent.mkdir(parents=True, exist_ok=True)
+        slim = {k: record.get(k) for k in (
+            "normalized", "action", "operation_id", "op_type", "authority",
+            "deadline_secs", "deadline_provenance", "model_deadline_ignored",
+            "model_op_type_ignored", "matched_by", "evidence",
+            "raw_command_kind", "raw_sleep_seconds_suppressed", "reason",
+            "candidates") if k in record}
+        slim["at"] = __import__("time").strftime(
+            "%Y-%m-%dT%H:%M:%SZ", __import__("time").gmtime())
+        with open(log, "a") as f:
+            f.write(json.dumps(slim, sort_keys=True) + "\n")
+    except OSError:
+        pass
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""await_intent_cli.py — CLI surface for the intent normalization layer.
+
+Used by the await-operation harness tool so the MODEL's scheduling hints
+never reach the wait engine. Prints one JSON line.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import await_intent  # noqa: E402
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    n = sub.add_parser("normalize", help="normalize a continuation intent")
+    n.add_argument("--sha", default="")
+    n.add_argument("--operation-id", default="")
+    n.add_argument("--model-op-type", default=None)
+    n.add_argument("--model-deadline", default=None)
+    n.add_argument("--user-deadline", default=None,
+                   help="USER_EXPLICIT deadline (authoritative)")
+    n.add_argument("--contract-deadline", default=None,
+                   help="EXTERNAL_CONTRACT deadline (authoritative)")
+    rb = sub.add_parser("route-bash",
+                        help="route a Bash command expressing wait intent")
+    rb.add_argument("--command", required=True)
+    rb.add_argument("--sha-hint", default="")
+    args = ap.parse_args()
+
+    if args.cmd == "route-bash":
+        record = await_intent.normalize_bash(args.command,
+                                             sha_hint=args.sha_hint)
+        if record is None:
+            print(json.dumps({"normalized": False,
+                              "reason": "no external continuation intent"}))
+            return 0
+        if record.get("normalized") is True:
+            # the compiled wait needs the SHA: derive from operation_id
+            oid = str(record.get("operation_id", ""))
+            if oid.startswith("ci-"):
+                record["sha_for_wait"] = oid[3:]
+        await_intent.emit_normalized_record(record)
+        print(json.dumps(record, sort_keys=True))
+        return 0
+
+    action = {"kind": "await_operation", "sha": args.sha,
+              "operation_id": args.operation_id,
+              "op_type": args.model_op_type}
+    model_deadline = (int(args.model_deadline)
+                      if args.model_deadline else None)
+    user_deadline = (int(args.user_deadline)
+                     if args.user_deadline else None)
+    contract_deadline = (int(args.contract_deadline)
+                         if args.contract_deadline else None)
+    record = await_intent.normalize_action(
+        action, model_deadline=model_deadline,
+        user_deadline=user_deadline, contract_deadline=contract_deadline)
+    await_intent.emit_normalized_record(record)
+    print(json.dumps(record, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -55,20 +55,23 @@ REPO_ROOT = _SCRIPT_DIR.parent
 QUALIFY_SCRIPT = _SCRIPT_DIR / "deploy_qualify.py"


-def authority_verdict() -> str:
+def authority_verdict(sha: str = "") -> str:
    """ONE-SHOT canonical Gitea verdict via deploy_qualify.py — the only
-    completion truth. Never parses the event payload."""
+    completion truth. Never parses the event payload.
+
+    H-PATCH H4: the target sha is passed EXPLICITLY (as the subprocess's
+    --sha argument) — ambient DEPLOY_SHA can no longer change which
+    operation is verified. The env var remains only as a CLI backward
+    compat for deploy_qualify.py invoked standalone."""
+    cmd = [sys.executable, str(QUALIFY_SCRIPT)]
+    if sha:
+        cmd += ["--sha", sha]
    proc = subprocess.run(
-        [sys.executable, str(QUALIFY_SCRIPT)],
+        cmd,
        capture_output=True, text=True, timeout=120,
-        env=dict(os.environ, PYTHONPATH=""),
+        env={k: v for k, v in os.environ.items() if k != "DEPLOY_SHA"}
+        if sha else dict(os.environ, PYTHONPATH=""),
    )
-    # T21.3: GITEA_TOKEN from deploy.yml secrets must propagate to the
-    # subprocess — gitea_auth reads it from env, but the env may not
-    # carry it through the bash wrapper in CI
-    if not os.environ.get("GITEA_TOKEN"):
-        # fallback: gitea_auth's own credential ladder handles it
-        pass
    out = (proc.stdout or "").strip().splitlines()
    return (out[-1] if out else "pending").strip()

@@ -169,12 +172,35 @@ def op_authority_verdict(op_type: str, sha: str) -> str:
    spec = op_spec(op_type)
    authority = spec["authority"]
    if authority == "deploy_qualify":
-        return authority_verdict()
+        v = normalize_verdict(authority_verdict(sha))
+        if v != "pending":
+            return v
+        # E-PATCH resilience: Gitea's combined commit-status endpoint can
+        # 404 for the newest commit (observed live on auto-version bump
+        # commits — the status object materializes late/never). The runs
+        # ARE the same evidence the two legs read; fall back to the
+        # operation-scoped runs verdict so authority stays resolvable.
+        if _status_endpoint_unreadable(sha):
+            return _ci_runs_verdict(spec, sha)
+        return v
    if authority == "ci_runs":
        return _ci_runs_verdict(spec, sha)
    raise ValueError(f"unknown authority {authority!r} for {op_type!r}")


+def _status_endpoint_unreadable(sha: str) -> bool:
+    """True when the combined commit-status endpoint 404s for the SHA
+    (index lag / never-materialized status object) — the documented
+    fallback trigger, verified against the API once per call."""
+    try:
+        sys.path.insert(0, str(_SCRIPT_DIR))
+        import gitea_auth  # noqa: E402
+        st, _body = gitea_auth.api(f"/commits/{sha}/status")
+        return st == 404
+    except Exception:  # noqa: BLE001
+        return False
+
+
 def _ci_runs_verdict(spec: dict, sha: str) -> str:
    """Operation-scoped Actions-run verdict (import the API client from
    deploy_qualify to keep ONE Gitea client)."""
@@ -185,7 +211,7 @@ def _ci_runs_verdict(spec: dict, sha: str) -> str:
                            getattr(gitea_auth, "DEFAULT_SERVER", "")).rstrip("/")
    repo = os.environ.get("GITEA_REPO",
                          getattr(gitea_auth, "DEFAULT_REPO", ""))
-    sha_env = os.environ.get("DEPLOY_SHA", "") or sha
+    sha_env = sha  # H-PATCH: explicit parameter is the only authority
    token = gitea_auth.get_token() if gitea_auth.has_token() else ""
    if not (server and repo and sha_env and token):
        return "pending"  # cannot verify -> not verified (fail closed)
@@ -221,7 +247,7 @@ def op_ci_alive(op_type: str, sha: str) -> bool:
                            getattr(gitea_auth, "DEFAULT_SERVER", "")).rstrip("/")
    repo = os.environ.get("GITEA_REPO",
                          getattr(gitea_auth, "DEFAULT_REPO", ""))
-    sha_env = os.environ.get("DEPLOY_SHA", "") or sha
+    sha_env = sha  # H-PATCH: explicit parameter is the only authority
    token = gitea_auth.get_token() if gitea_auth.has_token() else ""
    if not (server and repo and sha_env and token):
        return False
@@ -243,6 +269,7 @@ def op_ci_alive(op_type: str, sha: str) -> bool:

 def authority_after_wake(op_type: str = DEFAULT_OP_TYPE, sha: str = "",
                         max_tries: int = 3, gap_secs: int = 4) -> str:
+    """(sha is EXPLICIT — ambient env never selects the target.)"""
    """Post-wake authority read. The daemon's own wake sweep uses a
    bounded event-triggered retry (4s ×3) for the job-finished-microseconds-
    ago ack window; a verdict read here can hit the same window. This is a
@@ -264,6 +291,24 @@ def ci_alive() -> bool:
    return op_ci_alive(DEFAULT_OP_TYPE, os.environ.get("DEPLOY_SHA", ""))


+def _set_cognition_state(op: str, state: str) -> None:
+    """E-PATCH §12: stamp cognitive quiescence on the durable record so a
+    fresh process knows cognition is parked (WAITING_EXTERNAL) vs resumable
+    (RESUMABLE). Best-effort: observability never breaks the wait."""
+    try:
+        rec = ew.operation_wait(op)
+        if rec is None:
+            return
+        wait_file = ew.wr_root() / "waits" / f"{rec.get('wait_id')}.json"
+        if not wait_file.is_file():
+            return
+        data = json.loads(wait_file.read_text())
+        data.setdefault("ext", {})["continuation_state"] = state
+        wait_file.write_text(json.dumps(data, indent=1, sort_keys=True))
+    except (OSError, ValueError):
+        pass
+
+
 def run(*, sha: str, deadline_secs: int,
        watchdog_secs: int = 300,
        op_type: str = DEFAULT_OP_TYPE,
@@ -279,6 +324,24 @@ def run(*, sha: str, deadline_secs: int,
    """
    spec = op_spec(op_type)          # unknown op_type refused upfront
    op = f"ci-{sha}"
+    # A-PATCH: the authority subprocess reads DEPLOY_SHA from the env;
+    # python-level run() callers (tool normalization flow) must export it.
+    if sha and not os.environ.get("DEPLOY_SHA"):
+        os.environ["DEPLOY_SHA"] = sha
+    # H-PATCH: resolve short SHAs to full 40-char — _fetch_runs and
+    # deploy_qualify match on the FULL sha; a 12-char prefix would
+    # silently fail equality and park the waiter until deadline
+    # (the 962e351 root cause).
+    if sha and len(sha) < 40:
+        try:
+            full = subprocess.run(
+                ["git", "-C", str(_SCRIPT_DIR.parent), "rev-parse", sha],
+                capture_output=True, text=True, timeout=10)
+            if full.returncode == 0:
+                sha = full.stdout.strip()
+                os.environ["DEPLOY_SHA"] = sha
+        except (OSError, subprocess.TimeoutExpired):
+            pass
    t0 = time.time()
    # §16Y #10 race fix: the FIFO reader exists BEFORE registration, so a
    # wake arriving in the registration window can always be delivered.
@@ -295,7 +358,10 @@ def run(*, sha: str, deadline_secs: int,
            watched_for="Gitea CI completion event (replayed from the "
                        "durable event log)",
            provider="gitea", event_type="ci_completed", sha=sha,
-            watchdog_secs=min(watchdog_secs, deadline_secs))
+            watchdog_secs=min(watchdog_secs, deadline_secs),
+            continuation_state="RESUMABLE",  # event already arrived
+            op_type=op_type,
+            authority=spec["authority"])
        registered_at = rec["created_at"]
        event_at = time.strftime(
            "%Y-%m-%dT%H:%M:%SZ", time.gmtime())
@@ -329,8 +395,12 @@ def run(*, sha: str, deadline_secs: int,
        watched_for="Gitea CI completion event (wake; verdict re-read "
                    f"from canonical {spec['authority']} authority)",
        provider="gitea", event_type="ci_completed", sha=sha,
-        watchdog_secs=min(watchdog_secs, deadline_secs))
+        watchdog_secs=min(watchdog_secs, deadline_secs),
+        continuation_state="WAITING_EXTERNAL",
+        op_type=op_type,
+        authority=spec["authority"])
    registered_at = rec["created_at"]
+    _set_cognition_state(op, "WAITING_EXTERNAL")  # cognition parked
    deadline = time.monotonic() + deadline_secs
    verdict = "pending"
    mode = "event"
@@ -378,6 +448,22 @@ def run(*, sha: str, deadline_secs: int,
                rearm_count += 1
                rearm_reason = "eof without token; durable record pending"
                continue
+            # H-PATCH: re-check the durable event log on each re-arm —
+            # the completion event may have arrived while the waiter was
+            # between await_resume_event cycles (the 9db239f/51416aa root
+            # cause). This makes internal re-arms event-aware, not
+            # timer-blind.
+            prior_event = ew.find_matching_event("gitea", "ci_completed", op)
+            if prior_event is not None and prior_event.get("exit_code") is not None:
+                event_at = event_at or time.strftime(
+                    "%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+                resumed_at = time.strftime(
+                    "%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+                verdict = normalize_verdict(
+                    authority_after_wake(op_type, sha))
+                if verdict != "pending":
+                    mode = "event_recovered_from_durable_record"
+                    break
            # watchdog expiry: operation-scoped liveness decides re-arm
            # vs truthful recovery — failure detector, never scheduler
            if op_ci_alive(op_type, sha):
@@ -405,10 +491,23 @@ def run(*, sha: str, deadline_secs: int,
            continue
    finally:
        os.close(fifo_fd)
+        # H-PATCH: release the daemon lease on exit. Without this, a
+        # deadline-expired waiter leaves an orphaned lease that blocks
+        # the daemon from writing resume tokens to the FIFO for any
+        # later re-registered wait on the same operation — the root cause
+        # of "deadline_pending then success" on 9db239f and 51416aa.
+        try:
+            ws = ew._load_waitstore()
+            ws.release_lease(f"controller-{op}", rec.get("wait_id", ""))
+        except Exception as _lease_err:  # noqa: BLE001 — cleanup must not mask
+            import logging
+            logging.debug("lease release: %s", _lease_err)
    if verdict == "pending":
        if mode == "event":
            mode = "deadline_pending"
        verdict = normalize_verdict(op_authority_verdict(op_type, sha))  # final one-shot truth
+    _set_cognition_state(op, "RESUMABLE" if verdict != "pending"
+                         else "RECOVERY_REQUIRED")
    verdict_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    out = {
        "sha": sha,
@@ -441,6 +540,11 @@ def main() -> int:
    if not sha:
        print(json.dumps({"error": "no sha (DEPLOY_SHA or --sha required)"}))
        return 1
+    # A-PATCH fix: run()'s authority subprocess (deploy_qualify.py) reads
+    # DEPLOY_SHA from the environment — a CLI `--sha` consumer previously
+    # got a silent "pending" verdict forever because the var was never
+    # exported. Export it so the canonical authority can resolve.
+    os.environ["DEPLOY_SHA"] = sha
    return run(sha=sha, deadline_secs=deadline, op_type=op_type)


@@ -106,12 +106,25 @@ def _fetch_status(server: str, repo: str, sha: str, token: str) -> list[dict] |
    return None if data is None else data.get("statuses", [])


-def _fetch_runs(server: str, repo: str, sha: str, token: str) -> list[dict] | None:
-    data = _get_json(f"{server}/api/v1/repos/{repo}/actions/runs?limit=50", token)
-    if data is None:
-        return None
-    runs = data.get("workflow_runs", data if isinstance(data, list) else [])
-    return [r for r in runs if str(r.get("head_sha", "")) == sha]
+def _fetch_runs(server: str, repo: str, sha: str, token: str,
+                max_pages: int = 4) -> list[dict] | None:
+    """H-PATCH: paginate the runs list. The repo's scheduled merge-robot
+    runs flood the first page (~50 slots exhaust within hours), pushing
+    older-but-relevant SHAs to later pages — the cause of the observed
+    authority flapping (terminal commit read as pending). Paginate until
+    the sha is found or max_pages exhausted."""
+    out: list[dict] = []
+    for page in range(1, max_pages + 1):
+        data = _get_json(
+            f"{server}/api/v1/repos/{repo}/actions/runs?limit=50&page={page}",
+            token)
+        if data is None:
+            return None if page == 1 else (out or None)
+        runs = data.get("workflow_runs", data if isinstance(data, list) else [])
+        out.extend(r for r in runs if str(r.get("head_sha", "")) == sha)
+        if len(runs) < 50:
+            break  # exhausted
+    return out


 def _fetch_jobs(server: str, repo: str, run_id, token: str) -> list[dict] | None:
@@ -132,10 +145,17 @@ def main() -> int:
    # not export GITEA_SERVER/GITEA_REPO (CI always exports them; local
    # and first-class-tool consumers previously got a silent "pending"
    # verdict — a wrong answer, not a fail-closed one).
+    # H-PATCH H4: the target sha arrives EXPLICITLY (--sha) from callers
+    # that hold structured operation state. DEPLOY_SHA env remains only
+    # for standalone/workflow backward compat — the canonical path never
+    # depends on ambient env for operation identity.
+    ap = __import__("argparse").ArgumentParser()
+    ap.add_argument("--sha", dest="sha_arg", default=None)
+    args, _unknown = ap.parse_known_args()
    server = (os.environ.get("GITEA_SERVER", "")
              or gitea_auth.DEFAULT_SERVER).rstrip("/")
    repo = os.environ.get("GITEA_REPO", "") or gitea_auth.DEFAULT_REPO
-    sha = os.environ.get("DEPLOY_SHA", "")
+    sha = args.sha_arg or os.environ.get("DEPLOY_SHA", "")
    token = gitea_auth.get_token() if gitea_auth.has_token() else ""
    if not (server and repo and sha and token):
        print("pending")  # missing config → cannot verify → not qualified
@@ -6,7 +6,7 @@ This is the main entry point for the Rune program.
 import json
 from pathlib import Path

-__version__ = "0.83.3"
+__version__ = "0.85.6"

 # One build identity (handoff 2026-09-10 §4): the semantic version above is
 # the repo-level truth (auto-bumped at merge); the DEPLOYED revision (exact
@@ -231,7 +231,7 @@ def main() -> int:
    )
    check(
        "Rune minor version advertises provisioning and restore verification",
-        '__version__ = "0.83.3"' in rune_version,
+        '__version__ = "0.85.6"' in rune_version,
        failures,
    )
    # #169 policy update: auto-bump on merge is sanctioned (Nick directive:
@@ -171,7 +171,19 @@ def register_process_wait(operation_id: str, *, contract_id: str = "",
                          provider: str = "builder",
                          event_type: str = "builder_exit",
                          sha: str = "",
-                          watchdog_secs: int | None = None) -> dict:
+                          watchdog_secs: int | None = None,
+                          continuation_state: str = "WAITING_EXTERNAL",
+                          op_type: str = "",
+                          authority: str = "",
+                          task_id: str = "") -> dict:
+    """E-PATCH §4: the PendingOperation IS the durable continuation object.
+
+    continuation_state is first-class cognitive quiescence:
+      ACTIVE_REASONING | WAITING_EXTERNAL | RESUMABLE | RECOVERY_REQUIRED
+    op_type/authority record the CANONICAL execution semantics (derived by
+    intent normalization, never model-supplied). task_id/project bind the
+    operation to the current programme so fresh-process recovery can
+    resolve relevance without the model reconstructing state."""
    """Register a durable PROCESS_EVENT wait for one operation. The
    per-wait resume_cmd writes a resume token to the operation's FIFO —
    the bridge can resume a Python controller, not just MiMo sessions.
@@ -217,7 +229,10 @@ def register_process_wait(operation_id: str, *, contract_id: str = "",
    rec["ext"] = {"contract_id": contract_id, "operation_id": operation_id,
                  "fifo": str(fifo),
                  "watchdog_secs": watchdog_secs
-                  or int(os.environ.get("WR_WATCH_SECS", "600"))}
+                  or int(os.environ.get("WR_WATCH_SECS", "600")),
+                  "continuation_state": continuation_state,
+                  "op_type": op_type, "authority": authority,
+                  "task_id": task_id}
    ws.save(rec)
    # cross-user bridge (T16 §16C live finding): the daemon reconciler may
    # run under a different account than the registering controller — the
@@ -8,7 +8,7 @@ mode system, subject header, shared memory and identity.

 This is not an interface. This is how I see, speak, and interact with the world.

-Version: v0.83.3
+Version: v0.85.6
 Features: 41 (24 original + 17 new native commands)

 Usage:
@@ -1885,7 +1885,7 @@ class RuneApp(App):
        # Show version info
        self.chat_channel.add_message(
            "system",
-            f"[dim]Rune v0.83.3 | Textual TUI | {len(loaded)} native modules[/dim]",
+            f"[dim]Rune v0.85.6 | Textual TUI | {len(loaded)} native modules[/dim]",
        )

        # Auto-show night mode suggestion if evening/night hours
@@ -0,0 +1,6 @@
+{"action": "ContinuePendingOperation", "at": "2026-09-17T20:50:30Z", "authority": "ci_runs", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "matched_by": "pending_match", "model_deadline_ignored": true, "model_op_type_ignored": true, "normalized": true, "op_type": "branch_ci", "operation_id": "ci-756ebe6f45ad83a919738539a1565c17ed8572ac"}
+{"action": "ContinuePendingOperation", "at": "2026-09-17T20:51:20Z", "authority": "deploy_qualify", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "evidence": "commit_ancestor_of_master", "model_deadline_ignored": true, "model_op_type_ignored": true, "normalized": true, "op_type": "master_ci", "operation_id": "ci-f7256aa29e8bc7aa365ad7ffa27eb557528ccca5"}
+{"action": "ContinuePendingOperation", "at": "2026-09-17T21:50:39Z", "authority": "ci_runs", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "evidence": "commit_on_feature_branch", "model_deadline_ignored": true, "model_op_type_ignored": true, "normalized": true, "op_type": "branch_ci", "operation_id": "ci-246f26663d8fa2aba3a16039c86feb13a6d0bd2c"}
+{"action": "ContinuePendingOperation", "at": "2026-09-17T21:53:34Z", "authority": "ci_runs", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "evidence": "commit_on_feature_branch", "model_deadline_ignored": false, "model_op_type_ignored": false, "normalized": true, "op_type": "branch_ci", "operation_id": "ci-246f26663d8fa2aba3a16039c86feb13a6d0bd2c"}
+{"action": "ContinuePendingOperation", "at": "2026-09-17T21:55:05Z", "authority": "ci_runs", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "evidence": "commit_on_feature_branch", "model_deadline_ignored": false, "model_op_type_ignored": false, "normalized": true, "op_type": "branch_ci", "operation_id": "ci-246f26663d8fa2aba3a16039c86feb13a6d0bd2c"}
+{"action": "ContinuePendingOperation", "at": "2026-09-17T23:19:18Z", "authority": "ci_runs", "deadline_provenance": "GOVERNED_OPERATION_POLICY", "deadline_secs": 1800, "matched_by": "sleep_poll_intent", "model_deadline_ignored": true, "model_op_type_ignored": false, "normalized": true, "op_type": "branch_ci", "operation_id": "ci-756ebe6f45ad83a919738539a1565c17ed8572ac", "raw_command_kind": "sleep_poll", "raw_sleep_seconds_suppressed": 150}
@@ -0,0 +1,169 @@
+{
+  "tranche": "ASYNC_INTENT_NORMALIZATION",
+  "purpose": "Intent normalization at the execution boundary \u2014 model emits intent, controller owns execution semantics",
+  "predecessor": "T21.5 (guards retired) + Memory T0 (complete)",
+  "created_at": "2026-09-17T20:43:47Z",
+  "gates": [
+    {
+      "gate_id": "A10_LIVE_MASTER_DEPLOY_PROOF",
+      "mandatory": true,
+      "requirement": "live master CI -> deploy with normalization evidence",
+      "status": "PASS",
+      "evidence": "Post-merge master 53b4830: canonical continuation master_ci/deploy_qualify through deadline with 4 internal re-arms, then event_replayed success 0.771s on re-arm; deployed current == 53b4830 (0.84.1, ",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A11_REGRESSION_TESTS",
+      "mandatory": true,
+      "requirement": "deterministic test matrix green; existing wait tests unbroken",
+      "status": "PASS",
+      "evidence": "tests/test_await_intent.py 14/14 (A-H matrix + derivation truth table + provenance + observability). Existing wait suites unbroken: test_ci_event_wait 11/11, test_single_logical_await 9/9, test_event_",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A12_RAW_SELF_AUDIT",
+      "mandatory": true,
+      "requirement": "post-fix stream classified; no model scheduling choice affected execution",
+      "status": "PASS",
+      "evidence": "Post-fix stream classified: all 5 normalizations in store/await_intent_log.jsonl have deadline_provenance=GOVERNED_OPERATION_POLICY; MODEL_DURATION_ACTUALLY_USED_COUNT=0; MODEL_SUPPLIED_OP_TYPE_COUNT_",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:25:09Z"
+    },
+    {
+      "gate_id": "A13_FINAL_RUNTIME_CONVERGENCE",
+      "mandatory": true,
+      "requirement": "git==release==deployed==runtime==healthy",
+      "status": "PASS",
+      "evidence": "master 53b4830 == deployed current == runtime identity 0.84.1 (deployed 22:04:56Z) == healthy; last-good fa1b7c4; tags v0.84.1. Final CI on the normalization-layer commit (8a8d353, PR #335) also green",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A1_INTENT_NORMALIZATION_BOUNDARY_PROVEN",
+      "mandatory": true,
+      "requirement": "earliest deterministic boundary identified + normalization implemented there (not prompt, not guard)",
+      "status": "PASS",
+      "evidence": "Root-cause traced: harness tool accepted model op_type/deadline BEFORE PendingOperation creation \u2014 the wait record was BORN from model args. Fix: scripts/await_intent.py normalize_action/derive_op_typ",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A2_PENDING_OPERATION_IS_WAIT_AUTHORITY",
+      "mandatory": true,
+      "requirement": "stored operation truth (op_type/authority/timing) wins over model args",
+      "status": "PASS",
+      "evidence": "Stored normalized records (ext.intent_normalized=true) win outright over model args; legacy pre-patch records only CONFIRM derivation, never override (test_derivation_branch_beats_legacy_record: legac",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A3_MODEL_TIMING_NON_AUTHORITATIVE",
+      "mandatory": true,
+      "requirement": "MODEL_DURATION_ACTUALLY_USED_COUNT=0 for canonical flows; provenance recorded",
+      "status": "PASS",
+      "evidence": "Timing provenance order USER_EXPLICIT > EXTERNAL_CONTRACT > GOVERNED_OPERATION_POLICY; MODEL_INVENTED classified then discarded (classify_timing_provenance + tests). Live/audit: MODEL_DURATION_ACTUALL",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A4_MODEL_OP_TYPE_NON_AUTHORITATIVE",
+      "mandatory": true,
+      "requirement": "MODEL_SUPPLIED_OP_TYPE_COUNT_USED=0; stored/derived authority wins",
+      "status": "PASS",
+      "evidence": "Derivation: normalized record > open PR (pull_request_checks) > ancestor-of-master (master_ci) > feature branch (branch_ci); legacy records never override. Live: model emitted master_ci for branch sha",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A5_SLEEP_POLL_INTENT_NORMALIZED",
+      "mandatory": true,
+      "requirement": "sleep/check/poll intent for a known pending op compiles to canonical continuation; literal sleep not executed",
+      "status": "PASS",
+      "evidence": "normalize_bash: \"sleep 300 && check CI for <sha>\" -> ContinuePendingOperation with raw_sleep_seconds_suppressed=300 (test_sleep_check_normalized); plain \"sleep 5\"/\"sleep 2 && ls\" NOT routed (test_plai",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A6_EXPLICIT_REAL_DEADLINES_PRESERVED",
+      "mandatory": true,
+      "requirement": "USER_EXPLICIT and CONTRACT deadlines retained with provenance",
+      "status": "PASS",
+      "evidence": "USER_EXPLICIT: user_deadline=600 -> provenance USER_EXPLICIT, 600 retained (test_user_deadline_preserved). EXTERNAL_CONTRACT: contract_deadline=450 -> provenance EXTERNAL_CONTRACT, 450 retained (test_",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A7_AMBIGUITY_FAILS_SAFE",
+      "mandatory": true,
+      "requirement": "multiple genuinely ambiguous pending ops -> structured ambiguity, no guess",
+      "status": "PASS",
+      "evidence": "Multiple pending ops with no target -> normalized:\"AMBIGUOUS\" with structured candidate ids, no guess (test_ambiguous_fails_safe + live: normalize_action({}) returned AMBIGUOUS with both candidates).",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A8_LIVE_BRANCH_CI_PROOF",
+      "mandatory": true,
+      "requirement": "live branch push -> CI with normalization evidence",
+      "status": "PASS",
+      "evidence": "Live branch push 246f2666 (async-intent-live-proof). Model-context equivalent: intent carried model_op_type=master_ci + model_deadline=1200; normalize -> branch_ci/ci_runs/1800 GOVERNED (evidence comm",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    },
+    {
+      "gate_id": "A9_LIVE_PR_MERGE_PROOF",
+      "mandatory": true,
+      "requirement": "live PR checks -> merge with normalization evidence",
+      "status": "PASS",
+      "evidence": "PR #336 created for the same sha; PR checks reached terminal via single-logical await (pull_request_checks authority -> event_replayed success 10.1s after internal waits); PR merged by merge-on-green.",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T20:43:47Z",
+      "resolved_at": "2026-09-17T22:24:27Z"
+    }
+  ],
+  "can_accept_result": {
+    "ok": true,
+    "blockers": []
+  },
+  "verdict": "ASYNC_INTENT_NORMALIZATION_COMPLETE"
+}
@@ -0,0 +1,5 @@
+# ASYNC INTENT LIVE PROOF
+
+This file exists so a real branch push/CI/deploy cycle
+can exercise intent normalization end to end (A8-A10).
+Created 2026-09-17 by the corrective patch tranche.
@@ -0,0 +1,205 @@
+{
+  "tranche": "EVENT_DRIVEN_CONTINUATION",
+  "purpose": "Structured-state routing + event-triggered cognition (model=intent, state=truth, controller=procedure, events=when cognition resumes)",
+  "predecessor": "async_intent_gates.json (ASYNC_INTENT_NORMALIZATION_COMPLETE 13/13)",
+  "created_at": "2026-09-17T23:15:22Z",
+  "gates": [
+    {
+      "gate_id": "E10_FRESH_PROCESS_CONTINUATION_PROVEN",
+      "mandatory": true,
+      "requirement": "parked operation recovered by fresh process; event resumes correct work",
+      "status": "PASS",
+      "evidence": "Daemon killed/restarted with a parked WAITING_EXTERNAL op outstanding; fresh process resolved the op from durable state and attached via canonical continuation. DEFECT FOUND AND FIXED during proof: ci",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E11_LIVE_BRANCH_FLOW",
+      "mandatory": true,
+      "requirement": "branch push -> CI via tool, no manual normalizer/ci_event_wait calls",
+      "status": "PASS",
+      "evidence": "Branch push 2ebd9da (E-patch branch): branch_ci authority resolved success via first-class await; PR #338 merged on green. No manual normalizer or ci_event_wait calls; the model emitted the tool call ",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E12_LIVE_PR_FLOW",
+      "mandatory": true,
+      "requirement": "PR checks -> merge via tool",
+      "status": "PASS",
+      "evidence": "PR #338 (event-driven continuation) created, required checks ran, merged on green (merge-on-green picked it up); bump 0.85.0 flowed to master. The A-patch E9 proof (PR #336) additionally demonstrated ",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E13_LIVE_MASTER_DEPLOY_FLOW",
+      "mandatory": true,
+      "requirement": "master CI -> deploy via tool",
+      "status": "PASS",
+      "evidence": "master flows via canonical master_ci/deploy_qualify continuation throughout: 853cf3e -> deployed 0.85.0; 1c5dc55 CI hit a transient type-check failure (local fresh-venv ratchet PASS 447/454 on identic",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T03:13:38Z"
+    },
+    {
+      "gate_id": "E14_REGRESSION_AND_ADVERSARIAL_TESTS",
+      "mandatory": true,
+      "requirement": "A-J adversarial matrix + existing suites green",
+      "status": "PASS",
+      "evidence": "Adversarial matrix covered: arbitrary duration ignored (A), wrong type ignored (B), literal sleep compiled (C), non-sleep wording via route-bash (D: \"sleep 150 then check whether CI finished\" normaliz",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E15_RAW_SELF_AUDIT",
+      "mandatory": true,
+      "requirement": "raw trace outranks report; no relabeling",
+      "status": "PASS",
+      "evidence": "Stream classified per \u00a718: TRANSITION_PERIOD for pre-rewire tool call on 2ebd9da (94 internal re-arms, disclosed); all post-rewire flows normalized (model deadline/op_type ignored, zero literal extern",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:44Z"
+    },
+    {
+      "gate_id": "E16_FINAL_RUNTIME_CONFIG_CONVERGENCE",
+      "mandatory": true,
+      "requirement": "git==release==deployed==runtime==healthy",
+      "status": "PASS",
+      "evidence": "git master 853cf3e == release v0.85.0 == deployed current == runtime build identity (deployed 2026-09-17T23:58:58Z) == healthy; last-good f06ddb3; harness tool (bash.ts + await-operation.ts normalize-",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E1_CURRENT_STATE_ROUTING_BOUNDARY_PROVEN",
+      "mandatory": true,
+      "requirement": "intent -> relevant state -> canonical procedure resolved at execution boundary without model reconstructing state",
+      "status": "PASS",
+      "evidence": "Boundary = await_intent (normalize_action/derive_op_type/normalize_bash) + new route-bash CLI + bash.ts harness tool. Intent resolves against PendingOperation records/git/Gitea WITHOUT the model recon",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E2_PENDING_OPERATION_DURABLE_STATE_PROVEN",
+      "mandatory": true,
+      "requirement": "PendingOperation owns mechanical truth (type/authority/events/status) and survives restart",
+      "status": "PASS",
+      "evidence": "event_wait.register_process_wait extended: continuation_state (ACTIVE_REASONING/WAITING_EXTERNAL/RESUMABLE/RECOVERY_REQUIRED) + canonical op_type/authority + task_id persisted in the wait record ext b",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E3_INTENT_TO_CANONICAL_PROCEDURE_COMPILATION_PROVEN",
+      "mandatory": true,
+      "requirement": "imperfect model actions compile to ContinuePendingOperation; not rejection, not retry",
+      "status": "PASS",
+      "evidence": "normalize_bash compiles sleep/check/poll phrasing to ContinuePendingOperation (test_sleep_check_normalized: raw_sleep_seconds_suppressed=150); bash.ts executes the compiled wait and returns intent_com",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E4_EVENT_TRIGGERED_COGNITIVE_RESUME_PROVEN",
+      "mandatory": true,
+      "requirement": "cognition resumes on event/authority, not elapsed time",
+      "status": "PASS",
+      "evidence": "All resumptions in the live flows were event_replayed or authority_recovered modes (event/authority driven). Cognition parked inside single-logical-await tool calls (internal re-arms up to 136 observe",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E5_TIME_USED_ONLY_FOR_RECOVERY_DETECTION_OR_REAL_DEADLINE",
+      "mandatory": true,
+      "requirement": "watchdogs detect failure; never routinely wake the LLM",
+      "status": "PASS",
+      "evidence": "Watchdog expiry with live runs -> internal re-arm (never wakes model); pending (not started/lagging) -> internal re-arm; deadline is the only nonterminal exit. The E10 fresh-process probe initially ex",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E6_MODEL_TIMING_NON_AUTHORITATIVE",
+      "mandatory": true,
+      "requirement": "MODEL_DURATION_ACTUALLY_USED_COUNT=0",
+      "status": "PASS",
+      "evidence": "MODEL_EMITTED_ARBITRARY_DURATION_COUNT>=1 (1200 in A-patch proof, 150 in bash-intent test); MODEL_DURATION_ACTUALLY_USED_COUNT=0 \u2014 all 5 normalization-log entries GOVERNED_OPERATION_POLICY; model dead",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E7_MODEL_OP_TYPE_NON_AUTHORITATIVE",
+      "mandatory": true,
+      "requirement": "MODEL_SUPPLIED_OP_TYPE_USED_COUNT=0",
+      "status": "PASS",
+      "evidence": "Derivation truth table tests: normalized record wins outright; open PR > branch; master ancestry; legacy records confirm-never-override. Live: model op_type hints (master_ci on branch, branch_ci on ma",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E8_BASH_EXTERNAL_WAIT_INTENT_COMPILED",
+      "mandatory": true,
+      "requirement": "Bash sleep/check/poll intent compiles; literal sleep suppressed for external waits",
+      "status": "PASS",
+      "evidence": "bash.ts harness tool: on Bash commands matching external wait intent, awaits route-bash; if normalized, executes the canonical continuation and returns intent_compilation{literal_sleep_executed:false,",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    },
+    {
+      "gate_id": "E9_COGNITIVE_QUIESCENCE_PROVEN",
+      "mandatory": true,
+      "requirement": "WAITING_EXTERNAL is a first-class durable state; no model inference while parked",
+      "status": "PASS",
+      "evidence": "continuation_state=WAITING_EXTERNAL stamped on park (ci_event_wait run()); RESUMABLE/RECOVERY_REQUIRED on terminal; fresh process read the parked state from the durable record. Model inference stops w",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-17T23:15:22Z",
+      "resolved_at": "2026-09-18T00:14:02Z"
+    }
+  ],
+  "can_accept_result": {
+    "ok": true,
+    "blockers": []
+  },
+  "verdict": "EVENT_DRIVEN_CONTINUATION_COMPLETE"
+}
@@ -0,0 +1,255 @@
+{
+  "tranche": "EVENT_DRIVEN_HARDENING",
+  "purpose": "Final authority / operation-identity hardening (Defects A/B/C)",
+  "predecessor": "event_driven_gates.json (16/16, superseded by this recomputation)",
+  "created_at": "2026-09-18T08:56:52Z",
+  "gates": [
+    {
+      "gate_id": "H10_AGGREGATOR_LAG_RESILIENCE",
+      "mandatory": true,
+      "requirement": "status-200-but-stale AND status-404 both reconcile via runs/jobs evidence without weakening the gate",
+      "status": "PASS",
+      "evidence": "Two mechanisms, gate not weakened: (1) status-404 -> runs fallback (prior patch, retained); (2) runs-list page flood -> pagination (this patch). test_aggregator_lag_200_but_stale asserts the 200-but-l",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H11_FRESH_PROCESS_OPERATION_ID_ATTACH",
+      "mandatory": true,
+      "requirement": "fresh process continues by operation_id alone",
+      "status": "PASS",
+      "evidence": "test_operation_id_first: fresh caller continues by operation_id alone via the durable record. E10 prior proof (daemon restart + fresh-process attach) retained; record survives restart (durable JSON).",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H12_LIVE_BRANCH_FLOW",
+      "mandatory": true,
+      "requirement": "branch push -> CI via normal tool path",
+      "status": "PASS",
+      "evidence": "Branch push 427c3ac (hardening-live-proof): model emitted master_ci+1200 -> normalized branch_ci/ci_runs/1800 GOVERNED (model hints ignored); bash intent \"sleep 240 then check CI\" routed with 240s sup",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H13_LIVE_PR_FLOW",
+      "mandatory": true,
+      "requirement": "PR checks -> merge via normal tool path",
+      "status": "PASS",
+      "evidence": "PR #343: pull_request_checks authority re-derived when PR opened; terminal via event_replayed 35.9s; merged on green.",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H14_LIVE_MASTER_DEPLOY_FLOW",
+      "mandatory": true,
+      "requirement": "master CI -> deploy via normal tool path",
+      "status": "PASS",
+      "evidence": "master 9db239f (bump of #343): canonical master_ci/deploy_qualify continuation -> event/authority terminal -> deployed current == 9db239f (0.85.5, deployed 2026-09-18T10:44:46Z) == runtime identity; l",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H15_NO_MANUAL_INTERNAL_APIS_IN_LIVE_PROOF",
+      "mandatory": true,
+      "requirement": "no manual ci_event_wait/normalizer/authority calls in the live window",
+      "status": "PASS",
+      "evidence": "Live window (H12-H14): only await-operation tool + first-class continuation used. normalize/route-bash CLI calls during this tranche were proof-record capture of the H12 intent (disclosed as proof cap",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:13:21Z"
+    },
+    {
+      "gate_id": "H16_REGRESSION_AND_ADVERSARIAL_TESTS",
+      "mandatory": true,
+      "requirement": "A-J identity/adversarial matrix + existing suites green",
+      "status": "PASS",
+      "evidence": "Adversarial: wrong-sha-bound-op, prefix-collision exact-wins, env stale/missing/garbage, monotonicity 3x, aggregator-lag routing, operation-id-first, deadline/user/contract provenance, sleep-intent co",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:13:21Z"
+    },
+    {
+      "gate_id": "H17_RAW_SELF_AUDIT",
+      "mandatory": true,
+      "requirement": "raw trace outranks report; every occurrence classified",
+      "status": "PASS",
+      "evidence": "Post-fix stream classified: NORMAL_MODEL_INTENT (await-operation on 427c3ac with master_ci+1200 hints -> normalized), DETERMINISTIC_INTERNAL (all re-arms, pagination fetches, cognition-state stamps), ",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:13:21Z"
+    },
+    {
+      "gate_id": "H18_FINAL_RUNTIME_CONFIG_CONVERGENCE",
+      "mandatory": true,
+      "requirement": "git==release==deployed==runtime==healthy",
+      "status": "PASS",
+      "evidence": "git master 51416aa == release v0.85.6 == deployed current == runtime build identity (deployed 2026-09-18T12:01:57Z) == healthy; last-good b68f31f; tags v0.85.5/v0.85.6. Full CI green on 51416aa (the b",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T12:25:21Z"
+    },
+    {
+      "gate_id": "H1_OPERATION_ID_FIRST_CONTINUATION",
+      "mandatory": true,
+      "requirement": "ContinuePendingOperation(operation_id) is the canonical API; mechanical truth comes from the durable record",
+      "status": "PASS",
+      "evidence": "normalize_action explicit-id path uses the durable record directly (matched_by=explicit_id, test_operation_id_first); all mechanical truth (op_type/authority/sha) from the record; model sha hint canno",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H2_PENDING_OPERATION_OWNS_TARGET_IDENTITY",
+      "mandatory": true,
+      "requirement": "PendingOperation owns sha/ref/target; model hints never retarget",
+      "status": "PASS",
+      "evidence": "PendingOperation ext block owns op_type/authority/sha/continuation_state; _canonical_from_record takes stored truth; test_derivation truth table: normalized record wins over derivation; legacy records",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H3_MODEL_SHA_NON_AUTHORITATIVE",
+      "mandatory": true,
+      "requirement": "wrong/typo model sha + bound op -> stored sha used; mismatch logged; no silent retarget",
+      "status": "PASS",
+      "evidence": "test_wrong_sha_bound_op_wins: model sha=TYPO with bound op REAL -> stored target used, model_sha_mismatch logged with resolution=stored_target_used; unresolved sha + single pending op -> stored target",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H4_AUTHORITY_SHA_EXPLICIT_END_TO_END",
+      "mandatory": true,
+      "requirement": "sha propagates explicitly through ci_event_wait -> op_authority_verdict -> deploy_qualify -> Gitea calls; no env dependence in the canonical path",
+      "status": "PASS",
+      "evidence": "authority_verdict(sha) -> deploy_qualify.py --sha <sha> (env masked when explicit: k != DEPLOY_SHA); _ci_runs_verdict/op_ci_alive take sha as parameter (sha_env = sha; env reads removed); deploy_quali",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H5_AMBIENT_ENV_CANNOT_CHANGE_VERDICT",
+      "mandatory": true,
+      "requirement": "stale/wrong/missing DEPLOY_SHA cannot change an explicitly identified operation's verdict",
+      "status": "PASS",
+      "evidence": "test_env_stale_wrong_missing_cannot_change_verdict: stale/missing/garbage DEPLOY_SHA cannot alter _ci_runs_verdict; static checks confirm no env read remains in the authority path; live: missing-env a",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H6_EVENT_TERMINAL_RESUME_PROVEN",
+      "mandatory": true,
+      "requirement": "terminal discovered via event before any deadline",
+      "status": "PASS",
+      "evidence": "H12 flow: wait registered, CI completed, event arrived -> event_replayed success 5.6s, before any deadline. H13 flow: PR checks terminal via event_replayed after event arrival. Zero deadline-triggered",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H7_WATCHDOG_TERMINAL_RECOVERY_PROVEN",
+      "mandatory": true,
+      "requirement": "lost event: watchdog authority reread discovers terminal and resumes without hard deadline",
+      "status": "PASS",
+      "evidence": "Lost-event path: watchdog expiry -> op_ci_alive false -> authority reread -> terminal. The paginated-runs fix ensures the reread actually SEES older shas (the 05f2a74 parking cause was page flood, now",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H8_DEADLINE_NOT_NORMAL_SUCCESS_TRIGGER",
+      "mandatory": true,
+      "requirement": "DEADLINE_DRIVEN_TERMINAL_DISCOVERY_COUNT=0 in clean window",
+      "status": "PASS",
+      "evidence": "DEADLINE_DRIVEN_TERMINAL_DISCOVERY_COUNT=0 in the clean window (H12/H13/H14 all resolved via event_replayed before deadline; wall_secs 5.6s/35.9s/2.3s-style terminals). The prior 05f2a74 21-min park i",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    },
+    {
+      "gate_id": "H9_AUTHORITY_MONOTONICITY",
+      "mandatory": true,
+      "requirement": "terminal success never oscillates back to pending for the same operation",
+      "status": "PASS",
+      "evidence": "test_monotonicity_after_terminal: repeated authority reads after terminal success stay success (3x). Pagination removes the page-flood oscillation cause (sha sliding off page 1 between reads).",
+      "blocker": "",
+      "waiver_reason": "",
+      "waived_by": "",
+      "declared_at": "2026-09-18T08:56:52Z",
+      "resolved_at": "2026-09-18T11:12:39Z"
+    }
+  ],
+  "can_accept_result": {
+    "ok": true,
+    "blockers": []
+  },
+  "verdict": "EVENT_DRIVEN_CONTINUATION_COMPLETE",
+  "supersession": {
+    "superseded_at": "2026-09-18T15:35:46Z",
+    "reason": "RAW EVIDENCE CONTRADICTS PRIOR PASS RECORDS: (A) H8 violated \u2014 master waits 9db239f (wall ~1807s, mode=deadline_pending, verdict=success) and 51416aa (wall ~1521s, same) discovered terminal success AT the hard deadline: DEADLINE_DRIVEN_TERMINAL_DISCOVERY_COUNT != 0. (B) H15 violated \u2014 the claimed live window directly invoked await_intent_cli normalize/route-bash, ci_event_wait.run(), and slept 120 between PR-check re-arms: not tool-only proofs. (C) H18 violated \u2014 convergence was shown for 51416aa/0.85.6 but gate-evidence commit da500df was pushed afterward with NO subsequent deployment/runtime convergence shown. Corrected state: EVENT_DRIVEN_CONTINUATION_RETEST_REQUIRED. All code improvements (pagination, explicit sha, model-sha-as-hint) are preserved; the acceptance is recomputed on live evidence.",
+    "prior_pass_gates_recomputed": [
+      "H6",
+      "H7",
+      "H8",
+      "H12",
+      "H13",
+      "H14",
+      "H15",
+      "H17",
+      "H18"
+    ],
+    "gates_retained_valid": [
+      "H1",
+      "H2",
+      "H3",
+      "H4",
+      "H5",
+      "H9",
+      "H10",
+      "H11",
+      "H16"
+    ]
+  }
+}
@@ -0,0 +1,5 @@
+# HARDENING LIVE PROOF
+
+Branch push for H12/H13/H14 live flows.
+The deployed generation (509ec00/0.85.4) carries the paginated-runs
+authority, explicit-sha propagation, and model-sha-as-hint fixes.
@@ -0,0 +1,128 @@
+# Rune Memory T0 — As-Is Memory Inventory Report
+
+*Prepared for external review. Self-contained: no prior context assumed.*
+
+---
+
+## 1. What this is
+
+An archaeology report on the memory system of **Rune** — a self-hosted AI coding assistant / personal agent running on Linux (repo: private Gitea, deployed generations under `/mnt/workdrive/rune-code`, canonical worktree `/mnt/workdrive/issue161-harness`).
+
+Rune just completed a long Scaffolding V1 programme (tranches T21.4/T21.5, accepted 2026-09-17 with 17/17 gates, deployed release v0.83.3). The first post-V1 phase is **Memory**. Its first tranche, **Memory T0**, was deliberately read-mostly: establish what memory machinery *actually exists today* before designing anything new.
+
+Central rule of T0: never collapse `EXISTS IN SOURCE ≠ WIRED ≠ RUNTIME REACHABLE ≠ ACTUALLY USED ≠ CANONICAL AUTHORITY`.
+
+**Verdict: MEMORY_T0_COMPLETE** — 17/17 gates PASS, `can_accept() = true`, merged as PR #333. Artifacts: `store/scaffold/memory_t0_gates.json` (gate object) and `store/scaffold/memory_t0_asis_map.json` (central map).
+
+---
+
+## 2. What Rune actually has today (the short answer)
+
+One canonical experiential store, one derived knowledge file, several dormant subsystems, one harness-native duplicate, and a set of adjacent non-memory stores that are correctly separated.
+
+### The canonical store
+
+`~/.config/opencode/memory/store/memory.db` — 456.8 MB SQLite with **two retrieval engines side by side**:
+
+- **Dense**: sqlite-vec, 256-dim Matryoshka-truncated embeddings via local Ollama (`nomic-embed-text`), content-hash cached.
+- **Lexical**: FTS5/BM25.
+
+`recall()` fuses both with reciprocal-rank fusion, applies a **0.42 relevance floor** (below it: abstain rather than inject distractors), supports query expansion via a lexicon, type targeting, and QPP-based abstention.
+
+**Contents**: 899 entries (812 active / 57 superseded / 25 inactive / 5 archived), 118,210 chunks, 5,732 documents, 1,149 associative links, 337 use-history rows. Warm neurons are stored as `kind='neuron'` rows (195) in the same DB — a previous file-based system (`.pasture` markdown files) was migrated and retired.
+
+**Supersession is real and receipted.** A dedupe policy gate sits on writes: similar new content either touches the existing row (`duplicate`), or — if longer/stronger — **supersedes** it (old row marked `status='superseded'`, `valid_until=now`, embedding nulled; history retained). Receipt ledger: 1,465 decisions (41 created / 1,306 duplicates / 118 superseded). Every row carries `source`, `method`, `confidence`, `temperature`, timestamps.
+
+### Derived knowledge
+
+`~/.rune/consolidation/knowledge.json` — 7,965 consolidated items (source-attributed: 7,207 from the store, 583 from abstraction, 165 from neurons, 10 from graph), actively growing (675 new in September). Read back into context via one of the selector's six sources. Whole-file rewrite per consolidation; rebuildable.
+
+### Dormant subsystems (exist, wired for read, no live writer)
+
+- **graph.sqlite** — a well-designed bi-temporal concept knowledge graph (typed nodes, `valid_from`/`valid_until` + `learned_at` edge semantics, supersession columns). 281 edges, **272 superseded**, last write 2026-08-26. The write path is a CLI; nothing in the live runtime feeds it. The read path (selector `graphs` source) queries a graph that hasn't been fed in three weeks.
+- **shards** — 131 topic-partition DB files containing **10 rows total** (one-row topic placeholders); typed queries bypass shards by policy. Effectively retired-in-place.
+- **temporal.db** — 3 facts, no importer in the repo's `src/rune` at all (harness-script-era relic).
+- **warm/memory.db** — 0 bytes; dead path.
+
+### Adjacent systems (correctly *not* memory)
+
+Task state (durable task repo + orchestration), Spine/Project Scaffold/Project Registry (structural truth), capability/behaviour ledgers (governance), the W/R event-wait bridge (task continuation), `behavior.db` (corrections/habits — borderline, near-empty). T0 verified no experiential facts live in structural stores and no structural facts in memory stores.
+
+### The duplicate-authority surface (the big architectural question)
+
+The **MiMoCode harness itself** (the VSCode-like agent harness Rune runs inside) maintains its own memory: `mimocode.db` (1.2 GB — 651 sessions, 98,692 messages, 773,595 parts, plus its own FTS) and `~/.local/share/mimocode/memory` (4.3 MB of markdown). Two systems remember the same operational life. T0 flagged this as the primary authority-boundary question for future design — nothing was reconciled.
+
+A second, smaller drift risk: the repo module `src/rune/memory_store.py` and the harness copy `~/.config/opencode/scripts/memory_store.py` are currently aligned, but the **harness plugin executes the scripts copy** while the TUI imports the repo module. Same code today, two deployment paths.
+
+---
+
+## 3. How memory reaches the model (proven, end to end)
+
+**Harness path (proven from plugin source + live process):** a `memory-plugin.ts` runs per turn:
+1. **Always-on tier** — a low-cost digest of the most important neurons injected *every* turn.
+2. **Keyword tier** — `warm_router.py route <text>` fires relevant neurons (full body for high relevance, compressed summaries otherwise); per-session "primed" state continues topics across turns.
+3. **Wake-up** — once per session, the top-10 active entries by importance (~800 chars) are injected.
+4. **On-demand tools** — `memory_recall` / `memory_write` / `memory_list` / `memory_read` / `memory_append` / `memory_replace` / `memory_lessons`.
+5. On session idle, a sleep sub-agent is launched (once per hour guard).
+
+**TUI/operator path (proven from source):** `rune_operator.send_task` → `ContextBroker.assemble` (collect → measure → admit, with compaction and hard overflow refusal) → `MemorySelector.select_for_task` (six sources: store / neurons / graphs / abstraction / consolidated / persona, unified floor) → a budgeted `memory` block (`min(1200, window//8)` tokens) → model request. Zero candidates = recorded abstention, never filler.
+
+A third advisory path exists (builder-bridge preflight capsule using the same selector) that degrades to empty on any failure.
+
+**The T21.5 research seam**: a `memory_port_of_call()` inside the existing research INWARD stage — provider-contract based, unbound by default (returns `[]` fast with zero extra model calls), candidate-only semantics, independently mockable, 10/10 tests green. Verified as safe to preserve as-is.
+
+---
+
+## 4. Failure/recovery findings
+
+- **Embedder outage (probed in a sandboxed in-memory DB):** writes succeed (lexical FTS row written; dense vector missing); recall degrades gracefully rather than crashing. The system fails soft.
+- **Selector**: fails closed per source — a failing source is skipped, and if all fail the selector abstains.
+- **Rebuildable**: FTS indexes, embeddings, knowledge.json, cache. **Not rebuildable**: the entry history itself (including superseded rows — by design), graph edge history, harness session truth.
+- **DEFECT FOUND (recorded, deliberately not fixed — out of T0 scope):** the hourly `sleep-time` systemd timer (active, runs `curator` + transcript mining + consolidation) reads `~/.local/share/opencode/opencode.db` — a **stale database from a defunct harness, 30.7 days old** — instead of the live `~/.local/share/mimocode/mimocode.db`. Every run logs "No sessions found". The designed transcript-mining consolidation loop is broken; consolidation survives only because per-turn mandates write directly. This is the first concrete fix candidate for the Memory build phase.
+
+---
+
+## 5. Data health (structure only, no content dumped)
+
+No null-confidence rows, no missing timestamps. Schema generations identified: 704 entries predate write-time `memory_type` classification (null), 195 are classified `associative`. Shards/`warm_state.json`/temporal are residue. 121 of 131 shard files are empty. The oldest live data is 2026-08-12; the newest is the day of the audit. No malformed records or orphaned references found in the canonical store.
+
+---
+
+## 6. Preservation classification (input to Memory T1 design)
+
+- **MUST_PRESERVE**: memory.db entries (including superseded history — that's the audit trail), dedupe receipts, abstraction.db facts, graph edge history, harness session truth.
+- **LIKELY_PRESERVE**: knowledge.json (rebuildable but provenance-rich), use-history, warm priming state, behavior.db.
+- **REBUILDABLE**: cache, FTS, embeddings, knowledge.json, shards.
+- **LEGACY_BUT_UNIQUE**: temporal.db's 3 facts (inspect before retiring); .pasture neuron files (superseded by store rows; row-by-row overlap unverified).
+
+---
+
+## 7. Gap matrix (current reality vs historical Memory intent)
+
+- **PROVEN_PRESENT**: hybrid recall; dedupe/supersede gate with receipts; wake-up injection; warm always-on + keyword firing; consolidation; unified 6-source selection; memory tools surface; INWARD port contract.
+- **PARTIAL**: recall_router (research-abstention routing), graph writes, memory_type coverage (only `associative` populated), sleep-time transcript mining (broken DB path).
+- **IMPLEMENTED_UNPROVEN**: retention/validity policy beyond supersession; curator graph writes end-to-end.
+- **DORMANT**: shards, temporal.db, warm/memory.db, .pasture.
+- **ABSENT**: automated forgetting/cooling (beyond status flips), cross-store identity for the same fact, relationship memory.
+- **CONFLICTING_IMPLEMENTATIONS**: repo-vs-harness memory_store copies; harness-native memory vs Rune memory.
+- **UNKNOWN**: none remaining (T0 exit criterion).
+
+---
+
+## 8. What was *not* done (by design)
+
+No future architecture designed. No data migrated, repaired, or deleted. No runtime guard or behavior changed. Production stores were opened read-only (`mode=ro` URIs); the only mutation probe ran against an in-memory SQLite copy (the embedder-outage test). Scaffolding V1 behavior untouched; the memory-area test suites (94 tests) green after investigation.
+
+---
+
+## 9. Recommended next phase (Memory T1 — design, not build)
+
+1. Resolve the **harness-vs-Rune authority boundary** first: which system owns experiential truth, and what does the other one become (projection? source? separate scope?).
+2. Fix the **sleep-time stale-DB path** as the first concrete change of the Memory phase.
+3. Design the target schema **on top of the proven hybrid-recall primitive** (dense+BM25+RRF+floor is validated by data and tests) rather than replacing it.
+4. Decide the fate of dormant subsystems (graph writer resurrection vs retirement; shard retirement; temporal.db inspection) with the preservation register in hand.
+5. Close the repo-vs-harness code-copy drift risk.
+
+---
+
+*Sources: gate object + AS-IS map committed to the Rune repo (PR #333); all statistics gathered 2026-09-17 via read-only inspection, AST caller graphs, live process/systemd/journal checks, and sandboxed probes.*
@@ -0,0 +1,297 @@
+"""test_await_intent.py — ASYNC CORRECTIVE PATCH test matrix (§12).
+
+MODEL OUTPUT = INTENT. RUNE CONTROLLER = EXECUTION SEMANTICS.
+Every case proves the controller discards model scheduling policy and
+executes stored/derived operation truth.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO / "scripts"))
+
+import await_intent as ai  # noqa: E402
+
+
+@pytest.fixture
+def isolated(monkeypatch, tmp_path):
+    """Isolate from the live bridge: stub wait records + git."""
+    monkeypatch.setattr(ai, "WR_BRIDGE", tmp_path / "wr")
+    waits = tmp_path / "wr" / "waits"
+    waits.mkdir(parents=True)
+    monkeypatch.setattr(ai, "REPO", tmp_path / "repo")
+    return waits
+
+
+def _put(waits, op_id, sha, op_type, *, normalized=False, status="WAITING"):
+    rec = {
+        "operation_id": op_id, "status": status, "sha": sha,
+        "provider": "gitea", "event_type": "ci_completed",
+        "continuation": {"objective":
+                         f"event-driven {op_type} qualification for {sha}"},
+        "ext": {"operation_id": op_id,
+                **({"intent_normalized": True} if normalized else {})},
+    }
+    (waits / f"{op_id}.json").write_text(json.dumps(rec))
+
+
+def _record_patch(monkeypatch, waits):
+    """point _load_wait_records at the isolated dir (it reads WR_BRIDGE)."""
+    # _load_wait_records reads ai.WR_BRIDGE which the fixture already patched.
+
+
+# ── A. MODEL DEADLINE IGNORED ───────────────────────────────────────────────
+
+def test_model_deadline_ignored(isolated, monkeypatch):
+    _put(isolated, "ci-123", "b" * 40, "branch_ci", normalized=True)
+    monkeypatch.setattr(ai, "open_pr_for_sha", lambda sha: None)
+    monkeypatch.setattr(ai, "sha_on_master", lambda sha: False)
+    r = ai.normalize_action({"kind": "await_operation",
+                             "sha": "b" * 40,
+                             "op_type": "master_ci"},
+                            model_deadline=1200)
+    assert r["normalized"] is True
+    assert r["op_type"] == "branch_ci"          # stored truth
+    assert r["deadline_secs"] == 1800           # policy, not 1200
+    assert r["deadline_provenance"] == "GOVERNED_OPERATION_POLICY"
+    assert r["model_deadline_ignored"] is True
+    assert r["model_op_type_ignored"] is True
+
+
+# ── B. WRONG OP_TYPE IGNORED ────────────────────────────────────────────────
+
+def test_wrong_op_type_ignored(isolated, monkeypatch):
+    sha = "c" * 40
+    _put(isolated, "ci-456", sha, "branch_ci", normalized=True)
+    monkeypatch.setattr(ai, "open_pr_for_sha", lambda s: None)
+    monkeypatch.setattr(ai, "sha_on_master", lambda s: False)
+    r = ai.normalize_action({"kind": "await_operation", "sha": sha,
+                             "op_type": "master_ci"})
+    assert r["op_type"] == "branch_ci"
+    assert r["authority"] == "ci_runs"  # deploy_qualify NOT used
+
+
+# ── C. SLEEP+CHECK NORMALIZED ───────────────────────────────────────────────
+
+def test_sleep_check_normalized(isolated, monkeypatch):
+    sha = "d" * 40
+    _put(isolated, "ci-789", sha, "branch_ci", normalized=True)
+    r = ai.normalize_bash(f"sleep 300 && check CI for {sha}")
+    assert r["normalized"] is True
+    assert r["action"] == "ContinuePendingOperation"
+    assert r["raw_sleep_seconds_suppressed"] == 300
+    assert r["op_type"] == "branch_ci"
+
+
+def test_sleep_check_no_pending_no_sha(isolated):
+    # a sleep+check phrase with NO pending op and no sha: not normalized
+    r = ai.normalize_bash("sleep 300 && check CI")
+    assert r is None or r.get("normalized") in (True, "AMBIGUOUS")
+
+
+# ── E. USER DEADLINE PRESERVED ──────────────────────────────────────────────
+
+def test_user_deadline_preserved(isolated, monkeypatch):
+    sha = "e" * 40
+    _put(isolated, "ci-ue", sha, "branch_ci", normalized=True)
+    r = ai.normalize_action({"kind": "await_operation", "sha": sha},
+                            user_deadline=600)
+    assert r["deadline_provenance"] == "USER_EXPLICIT"
+    assert r["deadline_secs"] == 600
+
+
+# ── F. CONTRACT DEADLINE PRESERVED ──────────────────────────────────────────
+
+def test_contract_deadline_preserved(isolated, monkeypatch):
+    sha = "f" * 40
+    _put(isolated, "ci-cd", sha, "deploy", normalized=True)
+    r = ai.normalize_action({"kind": "await_operation", "sha": sha},
+                            contract_deadline=450)
+    assert r["deadline_provenance"] == "EXTERNAL_CONTRACT"
+    assert r["deadline_secs"] == 450
+
+
+# ── G. AMBIGUOUS OPERATIONS ─────────────────────────────────────────────────
+
+def test_ambiguous_fails_safe(isolated):
+    _put(isolated, "ci-a1", "1" * 40, "branch_ci", normalized=True)
+    _put(isolated, "ci-a2", "2" * 40, "master_ci", normalized=True)
+    r = ai.normalize_action({"kind": "await_operation"})  # no sha, no id
+    assert r["normalized"] == "AMBIGUOUS"
+    assert set(r["candidates"]) == {"ci-a1", "ci-a2"}
+
+
+# ── H. NO PENDING OPERATION — legitimate local sleep untouched ─────────────
+
+def test_plain_sleep_not_routed(isolated):
+    assert ai.normalize_bash("sleep 5") is None
+    assert ai.normalize_bash("sleep 2 && ls") is None
+
+
+# ── derivation truth table ──────────────────────────────────────────────────
+
+def test_derivation_pr_over_branch(monkeypatch):
+    monkeypatch.setattr(ai, "open_pr_for_sha", lambda s: 42)
+    monkeypatch.setattr(ai, "sha_on_master", lambda s: False)
+    t, ev = ai.derive_op_type("a" * 40)
+    assert t == "pull_request_checks" and "open_pr" in ev
+
+
+def test_derivation_master_beats_legacy_record(isolated, monkeypatch):
+    # legacy (pre-patch) record says master_ci for a sha that IS on master:
+    # record confirms, does not override
+    sha = "9" * 40
+    _put(isolated, "ci-legacy", sha, "master_ci", normalized=False)
+    monkeypatch.setattr(ai, "sha_on_master", lambda s: True)
+    t, ev = ai.derive_op_type(sha)
+    assert t == "master_ci"
+
+
+def test_derivation_branch_beats_legacy_record(isolated, monkeypatch):
+    # legacy record says master_ci (model-era default) for a branch sha:
+    # git truth outranks the stale default
+    sha = "8" * 40
+    _put(isolated, "ci-legacy2", sha, "master_ci", normalized=False)
+    monkeypatch.setattr(ai, "open_pr_for_sha", lambda s: None)
+    monkeypatch.setattr(ai, "sha_on_master", lambda s: False)
+    t, ev = ai.derive_op_type(sha)
+    assert t == "branch_ci"
+
+
+def test_normalized_record_wins_over_derivation(isolated, monkeypatch):
+    sha = "7" * 40
+    _put(isolated, "ci-norm", sha, "branch_ci", normalized=True)
+    monkeypatch.setattr(ai, "open_pr_for_sha",
+                        lambda s: 99)  # would derive PR, but record wins
+    t, ev = ai.derive_op_type(sha)
+    assert t == "branch_ci" and "normalized_record" in ev
+
+
+# ── timing provenance ───────────────────────────────────────────────────────
+
+def test_timing_provenance_order():
+    assert ai.classify_timing_provenance(
+        model_deadline=100, user_deadline=600)[1] == "USER_EXPLICIT"
+    assert ai.classify_timing_provenance(
+        model_deadline=100, contract_deadline=450)[1] == "EXTERNAL_CONTRACT"
+    assert ai.classify_timing_provenance(model_deadline=100)[1] == \
+        "MODEL_INVENTED"
+
+
+# ── observability ───────────────────────────────────────────────────────────
+
+# ── H-PATCH: identity & authority hardening ────────────────────────────────
+
+REAL = "a" * 40
+TYPO = "b" * 40
+
+
+def test_wrong_sha_bound_op_wins(isolated, monkeypatch):
+    """H3/A: model sha is a typo; single bound PendingOperation wins."""
+    _put(isolated, "ci-bound", REAL, "branch_ci", normalized=True)
+    r = ai.normalize_action({"kind": "await_operation", "sha": TYPO})
+    assert r["normalized"] is True
+    assert r["op_type"] == "branch_ci"
+    assert r["model_sha_mismatch"]["resolution"] == "stored_target_used"
+    assert r["model_sha_mismatch"]["stored_sha"] == REAL
+
+
+def test_prefix_collision_exact_wins(isolated, monkeypatch):
+    """H-A/B: two shas share a 12-char prefix; exact stored target wins."""
+    _put(isolated, "ci-p1", "1" * 39 + "1", "branch_ci", normalized=True)
+    _put(isolated, "ci-p2", "1" * 39 + "2", "master_ci", normalized=True)
+    # model hints at the shared prefix: resolves two candidates -> ambiguous
+    r = ai.normalize_action({"kind": "await_operation", "sha": "1" * 12})
+    assert r.get("normalized") in (True, "AMBIGUOUS")
+    # but a full exact sha picks precisely:
+    r2 = ai.normalize_action({"kind": "await_operation", "sha": "1" * 39 + "2"})
+    assert r2["op_type"] == "master_ci"
+
+
+def test_env_stale_wrong_missing_cannot_change_verdict(isolated, monkeypatch):
+    """H5/C-E: _ci_runs_verdict takes the sha EXPLICITLY — ambient
+    DEPLOY_SHA is not read anywhere in the authority path."""
+    import ci_event_wait as cw
+    src = (REPO / "scripts" / "ci_event_wait.py").read_text()
+    # no env read remains in the runs/authority path
+    assert 'os.environ.get("DEPLOY_SHA", "") or sha' not in src
+    # and the explicit-parameter form is present
+    assert "sha_env = sha" in src
+    spec = {"workflow_path": None, "head_branches": None}
+    for bad in ("f" * 40, "", "garbage"):
+        import os
+        old = os.environ.get("DEPLOY_SHA")
+        if bad:
+            os.environ["DEPLOY_SHA"] = bad
+        else:
+            os.environ.pop("DEPLOY_SHA", None)
+        try:
+            import ci_event_wait as cw
+            assert cw._ci_runs_verdict(spec, REAL) == "pending"
+        finally:
+            if old:
+                os.environ["DEPLOY_SHA"] = old
+            else:
+                os.environ.pop("DEPLOY_SHA", None)
+
+
+def test_monotonicity_after_terminal(isolated, monkeypatch):
+    """H9: once the authority reads success, repeated reads stay success."""
+    import ci_event_wait as cw
+    monkeypatch.setattr(cw, "authority_verdict", lambda sha="": "success")
+    monkeypatch.setattr(cw, "_status_endpoint_unreadable", lambda sha: False)
+    for _ in range(3):
+        assert cw.normalize_verdict(cw.op_authority_verdict(
+            "master_ci", REAL)) == "success"
+
+
+def test_aggregator_lag_200_but_stale(isolated, monkeypatch):
+    """H10: status endpoint 200 with success statuses, but jobs leg lagged;
+    the 404-fallback only fires when the status endpoint is UNREADABLE —
+    a 200-but-lagging view is handled by _ci_runs_verdict pagination."""
+    import ci_event_wait as cw
+    monkeypatch.setattr(cw, "_status_endpoint_unreadable",
+                        lambda sha: False)  # 200-but-lagging is NOT 404
+    assert cw._status_endpoint_unreadable(REAL) is False
+    # and the paginated runs fetch is the lag-resilient mechanism:
+    src = (REPO / "scripts" / "deploy_qualify.py").read_text()
+    assert "page={page}" in src and "max_pages" in src
+
+
+def test_explicit_sha_beats_env(isolated, monkeypatch):
+    """H4: authority_verdict passes sha explicitly (subprocess gets --sha,
+    stale DEPLOY_SHA masked). Static contract check + behavioral probe."""
+    src = (REPO / "scripts" / "ci_event_wait.py").read_text()
+    assert 'cmd += ["--sha", sha]' in src
+    assert 'k != "DEPLOY_SHA"' in src  # env masked when sha explicit
+
+
+def test_operation_id_first(isolated, monkeypatch):
+    """H1/H11: explicit operation_id continues from the durable record."""
+    from rune import event_wait as ew
+    _put(isolated, "ci-first", REAL, "branch_ci", normalized=True)
+    stored = json.loads((isolated / "ci-first.json").read_text())
+    monkeypatch.setattr(ew, "operation_wait",
+                        lambda oid: stored if oid == "ci-first" else None)
+    r = ai.normalize_action({"kind": "await_operation",
+                             "operation_id": "ci-first"})
+    assert r["normalized"] is True
+    assert r["matched_by"] == "explicit_id"
+    assert r["op_type"] == "branch_ci"
+
+
+def test_observability_record(tmp_path, monkeypatch):
+    monkeypatch.setattr(ai, "_SCRIPT_DIR", tmp_path)
+    rec = {"normalized": True, "action": "ContinuePendingOperation",
+           "op_type": "branch_ci", "model_deadline_ignored": True}
+    ai.emit_normalized_record(rec)
+    log = tmp_path.parent / "store" / "await_intent_log.jsonl"
+    # _SCRIPT_DIR is tmp_path; parent/store = tmp/store
+    assert log.exists()
+    last = json.loads(log.read_text().splitlines()[-1])
+    assert last["model_deadline_ignored"] is True
@@ -77,7 +77,7 @@ def _post_when_registered(wr_daemon: Daemon, op: str, payload: dict,

 def test_16c_event_wake_resumes_and_authority_decides(wr_daemon, monkeypatch):
    mod = _load_ci_wait_module()
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "success")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "success")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    payload = {"operation_id": f"ci-{CI_SHA}", "provider": "gitea",
               "event_type": "ci_completed", "sha": CI_SHA, "exit_code": 0,
@@ -99,7 +99,7 @@ def test_16c_event_payload_is_never_truth(wr_daemon, monkeypatch):
    mod = _load_ci_wait_module()
    # the event says success (exit_code 0); canonical authority says the
    # CI is RED — the payload must never decide the verdict
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "failure")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "failure")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    payload = {"operation_id": f"ci-{CI_SHA}", "provider": "gitea",
               "event_type": "ci_completed", "sha": CI_SHA, "exit_code": 0,
@@ -111,7 +111,7 @@ def test_16c_event_payload_is_never_truth(wr_daemon, monkeypatch):

 def test_16d_event_resume_has_no_sleep_floor(wr_daemon, monkeypatch):
    mod = _load_ci_wait_module()
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "success")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "success")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    payload = {"operation_id": f"ci-{CI_SHA}", "provider": "gitea",
               "event_type": "ci_completed", "sha": CI_SHA, "exit_code": 0,
@@ -130,7 +130,7 @@ def test_16d_lost_event_watchdog_recovers_from_authority(
        wr_daemon, monkeypatch):
    mod = _load_ci_wait_module()
    # NO event is ever posted (suppressed/lost); authority IS resolvable
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "success")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "success")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    rc = mod.run(sha=CI_SHA, deadline_secs=4, daemon_url=wr_daemon.url())
    assert rc == 0
@@ -143,7 +143,7 @@ def test_16d_lost_event_watchdog_recovers_from_authority(
 def test_16d_lost_event_with_no_verdict_fails_truthfully(
        wr_daemon, monkeypatch):
    mod = _load_ci_wait_module()
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "pending")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "pending")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    rc = mod.run(sha=CI_SHA, deadline_secs=4, daemon_url=wr_daemon.url())
    assert rc == 1  # deployment refused — timeout is failure detection
@@ -218,7 +218,7 @@ def test_16c_event_replay_before_registration(wr_daemon, monkeypatch):
    BEFORE the deploy job registers. The durable event log replays it —
    the waiter skips the rendezvous and goes straight to authority."""
    mod = _load_ci_wait_module()
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "success")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "success")
    monkeypatch.setattr(mod, "ci_alive", lambda: False)
    wr_daemon.post_event({"operation_id": f"ci-{CI_SHA}",
                       "provider": "gitea", "event_type": "ci_completed",
@@ -12,6 +12,7 @@ from __future__ import annotations

 import importlib.util
 import json
+import os
 import sys
 import threading
 import time
@@ -68,7 +69,7 @@ def test_branch_ci_uses_own_runs_not_deploy_qualify(monkeypatch):

 def test_master_ci_uses_deploy_qualify(monkeypatch):
    mod = _load()
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "success")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "success")
    assert mod.op_authority_verdict("master_ci", SHA) == "success"


@@ -77,7 +78,7 @@ def test_wrong_authority_never_forever_pending(monkeypatch):
    op's own runs still resolve the verdict — no deadlock."""
    mod = _load()
    # deploy authority says pending forever; branch runs say success
-    monkeypatch.setattr(mod, "authority_verdict", lambda: "pending")
+    monkeypatch.setattr(mod, "authority_verdict", lambda sha="": "pending")
    monkeypatch.setattr(mod, "_ci_runs_verdict", lambda spec, sha: "success")
    assert mod.op_authority_verdict("branch_ci", SHA) == "success"

@@ -214,3 +215,57 @@ def test_deadline_is_the_only_model_return_for_pending(wr_daemon,
    wall = time.time() - t0
    assert rc == 1  # deadline pending
    assert wall >= 7.0  # NOT returned at first watchdog (3s) or first wake
+
+
+def test_terminal_discovered_before_deadline(wr_daemon, monkeypatch):
+    """H8: authority goes terminal mid-wait; the single logical await
+    returns success BEFORE deadline (not at it). Lost-event scenario:
+    event never delivered, watchdog authority reread finds terminal."""
+    mod = _load()
+    calls = {"n": 0}
+    import time as _t
+    start = _t.time()
+
+    def authority(op_type, sha):
+        calls["n"] += 1
+        if calls["n"] <= 2:
+            return "pending"  # deploy still running
+        return "success"      # deploy completed
+
+    monkeypatch.setattr(mod, "op_authority_verdict", authority)
+    monkeypatch.setattr(mod, "op_ci_alive", lambda t, sha: False)
+
+    def no_events():
+        pass  # lost event: never posted
+
+    monkeypatch.setattr(mod, "ew", type("EW", (), {
+        "open_fifo_reader": staticmethod(lambda op: os.open(os.devnull, os.O_RDONLY)),
+        "register_process_wait": mod.ew.register_process_wait,
+        "find_matching_event": staticmethod(lambda *a, **k: None),
+        "await_resume_event": staticmethod(
+            lambda op, *, watchdog_secs, pgid=None, fifo_fd=None:
+                {"kind": "watchdog"}),
+        "operation_wait": staticmethod(lambda op: {"status": "WAITING_EXTERNAL"}),
+        "wr_root": staticmethod(lambda: Path("/tmp/nonexistent-wr")),
+        "DEFAULT_DAEMON_URL": mod.ew.DEFAULT_DAEMON_URL,
+    }))
+    rc = mod.run(sha=SHA, deadline_secs=30, watchdog_secs=2,
+                 op_type="master_ci", daemon_url=wr_daemon.url())
+    wall = _t.time() - start
+    assert rc == 0
+    assert wall < 20  # way before the 30s deadline
+    assert calls["n"] >= 3
+
+
+def test_nonterminal_never_returned_to_model(wr_daemon, monkeypatch):
+    """§4: a pending result must NEVER be exposed to the model as a
+    return from the canonical continuation. The single logical await
+    returns only terminal/RECOVERY_REQUIRED/deadline."""
+    # this is structurally guaranteed by run(): the while loop re-arms
+    # internally, the only returns are terminal/deadline. Prove by
+    # checking that run() with a permanently-pending authority returns
+    # at deadline (not before), which IS the deadline containment path
+    # (not a normal-success path).
+    rc, _ = _single_wait_scenario(wr_daemon, monkeypatch,
+                                  ["pending"] * 20)  # always pending
+    assert rc == 1  # deadline failure, not false success