chore(release): auto-bump version to 0.84.2 — earned by #337 (chore(async-intent): 13/13 gates — ASYNC_INTENT_NORMALIZATION_COMPLETE)

Promotion record: #337

README.md

@@ -1,6 +1,6 @@
 # Rune
 
-**Current release: v0.83.3**
+**Current release: v0.84.2**
 
 **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.**
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rune"
-version = "0.83.3"
+version = "0.84.2"
 description = "Rune — a stateful coding assistant with persistent memory, orchestration, and TUI"
 requires-python = ">=3.10"
 

scripts/await_intent.py

@@ -0,0 +1,375 @@
+"""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
+    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:
+        return _canonical_from_record(candidates[0], model_deadline_ignored,
+                                      model_op_type_ignored, "pending_match",
+                                      user_deadline, contract_deadline)
+
+    # 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)
+    else:
+        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,
+        }
+    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

scripts/await_intent_cli.py

@@ -0,0 +1,50 @@
+#!/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)")
+    args = ap.parse_args()
+
+    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())

src/rune/__init__.py

@@ -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.84.2"
 
 # 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

src/rune/canary_gitea_automation.py

@@ -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.84.2"' in rune_version,
         failures,
     )
     # #169 policy update: auto-bump on merge is sanctioned (Nick directive:

src/rune/rune_tui.py

@@ -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.84.2
 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.84.2 | Textual TUI | {len(loaded)} native modules[/dim]",
         )
 
         # Auto-show night mode suggestion if evening/night hours

store/await_intent_log.jsonl

@@ -0,0 +1,5 @@
+{"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"}

store/scaffold/async_intent_gates.json

@@ -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"
+}

store/scaffold/async_intent_live_proof.md

@@ -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.

store/scaffold/memory_t0_external_report.md

@@ -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.*

tests/test_await_intent.py

@@ -0,0 +1,197 @@
+"""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 ───────────────────────────────────────────────────────────
+
+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