loki-mode 9.12.4 → 9.12.6

package/VERSION

@@ -1 +1 @@
-9.12.4
+9.12.6

package/autonomy/loki

@@ -27881,11 +27881,17 @@ except: pass
 
     # --- Build directory tree ---
     local tree_output=""
-    if command -v git &>/dev/null && [ -d "$target_path/.git" ]; then
+    # -e not -d: in a git WORKTREE, .git is a pointer FILE, not a directory.
+    # -d sent every worktree down the find fallback below.
+    if command -v git &>/dev/null && [ -e "$target_path/.git" ]; then
         # Use git ls-files for accurate tree (respects .gitignore)
         tree_output=$(cd "$target_path" && git ls-files 2>/dev/null | head -200 || true)
     else
-        # Fallback: find with common excludions
+        # Fallback: find with common excludions.
+        # `|| true` is load-bearing under `set -euo pipefail` (line 22): head -200
+        # exits after 200 lines, find keeps writing, gets SIGPIPE, and the pipeline
+        # returns 141 -- which -e turned into a silent abort producing 0 bytes on
+        # any repo with more than 200 files. The git branch above is already guarded.
         tree_output=$(find "$target_path" -maxdepth 4 -type f \
             -not -path '*/node_modules/*' \
             -not -path '*/.git/*' \
@@ -27895,7 +27901,7 @@ except: pass
             -not -path '*/build/*' \
             -not -path '*/.next/*' \
             -not -path '*/target/*' \
-            2>/dev/null | sed "s|$target_path/||" | sort | head -200)
+            2>/dev/null | sed "s|$target_path/||" | sort | head -200 || true)
     fi
 
     # Categorize files
@@ -28652,8 +28658,13 @@ $devdeps_list"
     fi
 
     # --- File counts ---
+    # Same SIGPIPE pipeline as cmd_onboard, but a DIFFERENT symptom here: this
+    # assigns into a bare `tree_output=` after the local declaration, so under
+    # -e a 141 aborts. Where a site instead writes `local x=$(...)`, `local`
+    # resets $? and the 141 is swallowed -- silent truncation, no abort. Both
+    # are wrong; `|| true` plus -e (worktree .git is a FILE) fixes both.
     local tree_output=""
-    if command -v git &>/dev/null && [ -d "$target_path/.git" ]; then
+    if command -v git &>/dev/null && [ -e "$target_path/.git" ]; then
         tree_output=$(cd "$target_path" && git ls-files 2>/dev/null | head -500 || true)
     else
         tree_output=$(find "$target_path" -maxdepth 4 -type f \
@@ -28661,7 +28672,7 @@ $devdeps_list"
             -not -path '*/vendor/*' -not -path '*/__pycache__/*' \
             -not -path '*/dist/*' -not -path '*/build/*' \
             -not -path '*/.next/*' -not -path '*/target/*' \
-            2>/dev/null | sed "s|$target_path/||" | sort | head -500)
+            2>/dev/null | sed "s|$target_path/||" | sort | head -500 || true)
     fi
     local total_files src_count test_count doc_count config_count
     total_files=$(echo "$tree_output" | { grep -c . || true; })
@@ -29065,9 +29076,10 @@ cmd_docs() {
 _docs_scan_project() {
     local target_path="$1"
 
-    # Build file tree (excluding common noise)
+    # Build file tree (excluding common noise).
+    # Same SIGPIPE pipeline and same fix as cmd_onboard; see the comment there.
     local tree_output=""
-    if command -v git &>/dev/null && [ -d "$target_path/.git" ]; then
+    if command -v git &>/dev/null && [ -e "$target_path/.git" ]; then
         tree_output=$(cd "$target_path" && git ls-files 2>/dev/null | head -500 || true)
     else
         tree_output=$(find "$target_path" -maxdepth 4 -type f \
@@ -29075,7 +29087,7 @@ _docs_scan_project() {
             -not -path '*/vendor/*' -not -path '*/__pycache__/*' \
             -not -path '*/dist/*' -not -path '*/build/*' \
             -not -path '*/.next/*' -not -path '*/target/*' \
-            2>/dev/null | sed "s|$target_path/||" | sort | head -500)
+            2>/dev/null | sed "s|$target_path/||" | sort | head -500 || true)
     fi
     echo "$tree_output"
 }

package/autonomy/verify.sh

@@ -2522,9 +2522,18 @@ try:
     # secrets/lint/deps). It must NEVER claim "verified" when the authoritative
     # verdict is not VERIFIED -- a tool named Verify printing "-> verified" next
     # to a BLOCKED result is a fake-green-shaped surface, and this product never
-    # lies about done. So the banner reports the engine's partial finding,
+    # lies about done. So the banner reports the partial finding of the engine,
     # explicitly subordinated to the authoritative verdict, and never the word
     # "verified" on its own when the verdict disagrees.
+    #
+    # NO APOSTROPHES IN THIS BODY. This heredoc sits inside "$( ... )", and bash
+    # 3.2 -- the /bin/bash that every stock macOS ships -- tracks quoting THROUGH
+    # the command substitution even though the heredoc is quoted with <<PYEOF.
+    # One apostrophe opens a quote that never closes, so the parser swallows the
+    # rest of the file and reports "syntax error near unexpected token (" at a
+    # line ~270 later that is perfectly valid. The whole file then fails to
+    # parse: `loki verify --help` exits 2 printing NOTHING on a stock Mac, while
+    # working fine under Homebrew bash 5. Verified by minimal reproduction.
     verdict = (os.environ.get("_V_VERDICT") or "").strip().upper()
     if e.get("inconclusive"):
         finding = "inconclusive (%s)" % (e.get("inconclusive_reason") or "no reason")

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "9.12.4"
+__version__ = "9.12.6"
 
 # Expose the control app for easy import
 try:

package/dashboard/api_operator.py

@@ -77,11 +77,24 @@ def _loki_dir() -> str:
     others, and an import-time snapshot would pin whichever was true when the
     module first loaded.
     """
-    return os.environ.get("LOKI_DIR") or os.path.join(os.getcwd(), ".loki")
+    return os.environ.get("LOKI_DIR") or os.path.join(_safe_getcwd(), ".loki")
+
+
+def _safe_getcwd() -> str:
+    """os.getcwd() raises FileNotFoundError once the cwd is deleted.
+
+    These helpers run per request, so letting that propagate turns a stale
+    working directory into a blanket 500 across the whole API. Fall back to
+    this package's tree, which is on disk by definition.
+    """
+    try:
+        return os.getcwd()
+    except OSError:
+        return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 
 def _repo_dir() -> str:
-    return os.environ.get("LOKI_REPO_DIR") or os.getcwd()
+    return os.environ.get("LOKI_REPO_DIR") or _safe_getcwd()
 
 
 # Ceilings for the receipt walk on the HTTP path. Generous enough that a real

package/dashboard/api_v2.py

@@ -527,7 +527,12 @@ async def list_runs(
             try:
                 from . import api_runs as _fs_runs
 
-                _loki = os.environ.get("LOKI_DIR") or os.path.join(os.getcwd(), ".loki")
+                # A deleted cwd raises from os.getcwd(); this runs per request.
+                try:
+                    _cwd = os.getcwd()
+                except OSError:
+                    _cwd = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+                _loki = os.environ.get("LOKI_DIR") or os.path.join(_cwd, ".loki")
                 _fs = _fs_runs.list_runs(_loki)
                 # The adapter returns an envelope carrying source, freshness
                 # and an explicit reason when empty. Never fabricate a row:

package/dashboard/control.py

@@ -72,22 +72,64 @@ def find_skill_dir() -> Path:
             return configured
         raise RuntimeError(f"LOKI_SKILL_DIR is not a Loki source tree: {configured}")
 
+    # os.getcwd() RAISES FileNotFoundError when the working directory has been
+    # deleted out from under the process. That is not hypothetical: a dashboard
+    # started inside a temp workspace keeps running after the workspace is
+    # cleaned up, and then EVERY endpoint that resolves a path 500s at once --
+    # observed as ~60 simultaneous 500s including /api/status, whose handler
+    # touches almost nothing. A long-lived server must survive losing its cwd.
+    def _cwd_or_none() -> "Path | None":
+        try:
+            return Path.cwd()
+        except OSError:
+            return None
+
     candidates = [
         Path.home() / ".claude" / "skills" / "loki-mode",
         Path(__file__).parent.parent,
-        Path.cwd()
+        _cwd_or_none(),
     ]
     for candidate in candidates:
-        if (candidate / "SKILL.md").exists() and (candidate / "autonomy" / "run.sh").exists():
-            return candidate
-    return Path.cwd()
+        if candidate is None:
+            continue
+        try:
+            if ((candidate / "SKILL.md").exists()
+                    and (candidate / "autonomy" / "run.sh").exists()):
+                return candidate
+        except OSError:
+            continue
+
+    # The fallback must not be the one path that can still raise. When the cwd
+    # is gone, resolve to this file's own tree -- it is on disk by definition,
+    # since we are executing out of it.
+    return _cwd_or_none() or Path(__file__).resolve().parent.parent
 
 SKILL_DIR = find_skill_dir()
 RUN_SH = SKILL_DIR / "autonomy" / "run.sh"
 
-# Ensure directories exist
-STATE_DIR.mkdir(parents=True, exist_ok=True)
-LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+def _cwd_or_skill_dir() -> Path:
+    """The cwd, or the skill tree when the cwd has been deleted.
+
+    Used where a real directory is required (subprocess cwd=), as opposed to
+    the confinement check in validate(), which must fail closed instead.
+    """
+    try:
+        return Path.cwd()
+    except OSError:
+        return SKILL_DIR
+
+# Ensure directories exist.
+# Best-effort at IMPORT time. LOKI_DIR defaults to the relative path ".loki",
+# so when the working directory has been deleted these mkdirs raise
+# FileNotFoundError and the whole module fails to import -- which takes the
+# entire dashboard down rather than the one feature that needs the directory.
+# Whoever actually writes into these paths still surfaces its own error.
+for _startup_dir in (STATE_DIR, LOG_DIR):
+    try:
+        _startup_dir.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        pass
 
 # Utility: atomic write with optional file locking
 def atomic_write_json(file_path: Path, data: dict, use_lock: bool = True):
@@ -202,8 +244,16 @@ class StartRequest(BaseModel):
         if not prd_path.is_file():
             raise ValueError(f"PRD path is not a file: {self.prd}")
 
-        # Verify path resolves within CWD or a reasonable parent
-        cwd = Path.cwd().resolve()
+        # Verify path resolves within CWD or a reasonable parent.
+        # FAIL CLOSED if the cwd is gone: this is a path-confinement check, so
+        # an unresolvable base must reject the path, never skip the comparison.
+        try:
+            cwd = Path.cwd().resolve()
+        except OSError as exc:
+            raise ValueError(
+                "cannot validate PRD path: the working directory no longer "
+                "exists (%s)" % exc
+            ) from exc
         try:
             prd_path.relative_to(cwd)
         except ValueError:
@@ -450,7 +500,9 @@ async def start_session(request: StartRequest):
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             start_new_session=True,
-            cwd=str(Path.cwd())
+            # A deleted cwd would make Popen itself raise; fall back to the
+            # skill tree rather than failing to launch the run at all.
+            cwd=str(_cwd_or_skill_dir())
         )
 
         # Save provider for status tracking

package/dashboard/server.py

@@ -4417,7 +4417,8 @@ async def start_build(request: Request, body: StartBuildRequest):
         loki_dir = workspace_dir / ".loki"
     else:
         loki_dir = _get_loki_dir()
-        project_dir = loki_dir.parent if loki_dir.name == ".loki" else _Path.cwd()
+        project_dir = (loki_dir.parent if loki_dir.name == ".loki"
+                       else (_safe_cwd() or _Path(".")))
         project_dir = project_dir.resolve()
 
     # Legacy no-workspace starts keep their existing single-flight behavior.
@@ -5637,6 +5638,22 @@ _active_project_dir: Optional[str] = None
 _DASHBOARD_AUTOSTARTED: bool = os.environ.get("LOKI_DASHBOARD_AUTOSTARTED") == "1"
 
 
+def _safe_cwd() -> "_Path | None":
+    """The current directory, or None if it no longer exists.
+
+    os.getcwd() RAISES FileNotFoundError when the working directory has been
+    deleted out from under a live process. A dashboard started inside a temp
+    workspace keeps serving after that workspace is cleaned up, and every
+    endpoint resolving a path then 500s simultaneously -- observed as ~60
+    concurrent 500s including /api/status, whose handler touches almost
+    nothing. Losing the cwd must degrade to a fallback, never to a stack trace.
+    """
+    try:
+        return _Path.cwd()
+    except OSError:
+        return None
+
+
 def _get_loki_dir() -> _Path:
     """Get LOKI_DIR, refreshing from env on each call for consistency.
 
@@ -5661,10 +5678,14 @@ def _get_loki_dir() -> _Path:
     if env_dir and _Path(env_dir).is_absolute():
         return _Path(env_dir)
 
-    # Check CWD first
-    cwd_loki = _Path.cwd() / ".loki"
-    if cwd_loki.is_dir():
-        return cwd_loki
+    # Check CWD first. _safe_cwd() rather than _Path.cwd(): this function runs
+    # on nearly every request, and a deleted working directory would otherwise
+    # raise FileNotFoundError here and 500 the entire API at once.
+    _cwd = _safe_cwd()
+    if _cwd is not None:
+        cwd_loki = _cwd / ".loki"
+        if cwd_loki.is_dir():
+            return cwd_loki
 
     # Check home directory fallback
     home_loki = _Path.home() / ".loki"

package/dashboard/static/index.html

@@ -11989,7 +11989,7 @@ var LokiDashboard=(()=>{var Be=Object.defineProperty;var zt=Object.getOwnPropert
         ${o}
         ${this._error?`<div class="error-banner">${this._escapeHtml(this._error)}</div>`:""}
       </div>
-    `,this._bindEvents()}};customElements.get("loki-rarv-timeline")||customElements.define("loki-rarv-timeline",be);function xt(d){if(!d||typeof d!="object")return null;let e=d.freshness_s;return typeof e!="number"||!Number.isFinite(e)||e<0?null:e}function _t(d){if(!Array.isArray(d))return null;let e=null;for(let t of d){let i=xt(t);i!==null&&(e===null||i<e)&&(e=i)}return e}function yt(d={}){let{payload:e=null,receivedAtMs:t=null,nowMs:i=Date.now(),staleAfterS:a=120}=d,s=xt(e),r=null,o="none";return s!==null?(r=s,o="server"):typeof t=="number"&&Number.isFinite(t)&&(r=Math.max(0,Math.floor((i-t)/1e3)),o="client"),{known:r!==null,ageS:r,source:o,isStale:r===null?null:r>=a,staleAfterS:a}}function ti(d){if(!d||!d.known||typeof d.ageS!="number")return"unknown";let e=d.ageS;return e<60?`${e}s ago`:e<3600?`${Math.floor(e/60)}m ago`:e<86400?`${Math.floor(e/3600)}h ago`:`${Math.floor(e/86400)}d ago`}function Ze(d){if(!d||!d.known)return"Data age unknown";let e=d.source==="client"?" (receive time)":"",t=d.isStale?" - STALE":"";return`Updated ${ti(d)}${e}${t}`}var wt={running:{color:"var(--loki-green, #22c55e)",bg:"var(--loki-green-muted, rgba(34, 197, 94, 0.15))",label:"Running"},completed:{color:"var(--loki-blue, #3b82f6)",bg:"var(--loki-blue-muted, rgba(59, 130, 246, 0.15))",label:"Completed"},failed:{color:"var(--loki-red, #ef4444)",bg:"var(--loki-red-muted, rgba(239, 68, 68, 0.15))",label:"Failed"},cancelled:{color:"var(--loki-yellow, #eab308)",bg:"var(--loki-yellow-muted, rgba(234, 179, 8, 0.15))",label:"Cancelled"},pending:{color:"var(--loki-text-muted, #939084)",bg:"var(--loki-bg-tertiary, #ECEAE3)",label:"Pending"},queued:{color:"var(--loki-text-muted, #939084)",bg:"var(--loki-bg-tertiary, #ECEAE3)",label:"Queued"}};function ii(d,e,t){let i=d;if(i==null&&e){let l=new Date(e).getTime();i=(t?new Date(t).getTime():Date.now())-l}if(i==null||i<0)return"--";if(i<1e3)return`${i}ms`;let a=Math.floor(i/1e3);if(a<60)return`${a}s`;let s=Math.floor(a/60),r=a%60;if(s<60)return`${s}m ${r}s`;let o=Math.floor(s/60),n=s%60;return`${o}h ${n}m`}function ai(d){if(!d)return"--";try{return new Date(d).toLocaleString([],{month:"short",day:"numeric",hour:"2-digit",minute:"2-digit"})}catch{return String(d)}}var ke=class extends v{static get observedAttributes(){return["api-url","project-id","theme"]}constructor(){super(),this._loading=!1,this._error=null,this._api=null,this._runs=[],this._pollInterval=null,this._lastDataHash=null,this._emptyReason=null,this._source=null,this._freshPayload=null,this._changedAtMs=null}_freshness(){let e=t=>{if(!t)return!1;if(t.current===!0)return!0;let i=String(t.status||"").toLowerCase();return i==="running"||i==="in_progress"||i==="active"};return yt({payload:this._freshPayload,receivedAtMs:this._changedAtMs,staleAfterS:this._runs.some(e)?void 0:1/0})}_renderFreshness(){let e=this.shadowRoot&&this.shadowRoot.getElementById("freshness");if(!e)return;let t=this._freshness();e.className=`freshness ${t.known?t.isStale?"is-stale":"":"is-unknown"}`,e.dataset.source=t.source,e.dataset.stale=t.isStale===null?"unknown":String(t.isStale),e.textContent=Ze(t)}get projectId(){let e=this.getAttribute("project-id");return e?parseInt(e,10):null}set projectId(e){e!=null?this.setAttribute("project-id",String(e)):this.removeAttribute("project-id")}connectedCallback(){super.connectedCallback(),this._setupApi(),this._loadData(),this._startPolling()}disconnectedCallback(){super.disconnectedCallback(),this._stopPolling()}attributeChangedCallback(e,t,i){t!==i&&(e==="api-url"&&this._api&&(this._api=h({baseUrl:i}),this._loadData()),e==="project-id"&&this._loadData(),e==="theme"&&this._applyTheme())}_setupApi(){let e=this.getAttribute("api-url")||window.location.origin;this._api=h({baseUrl:e})}_startPolling(){this._poll=b({loadFn:()=>this._loadData(),intervalMs:5e3,element:this,immediate:!1})}_stopPolling(){this._poll&&(this._poll.stop(),this._poll=null)}async _loadData(){let e=this._api;try{let t=this.projectId,i=t!=null?`?project_id=${t}`:"",a=await e._get(`/api/v2/runs${i}`);if(e!==this._api)return;let s=a?.runs||a||[],r=Array.isArray(s)?s:[];this._freshPayload=a&&typeof a=="object"&&!Array.isArray(a)&&"freshness_s"in a?a:{freshness_s:_t(r)};let o=JSON.stringify(s),n=o!==this._lastDataHash||!!this._error;n&&(this._lastDataHash=o,this._runs=r,this._changedAtMs=Date.now()),this._emptyReason=a&&!Array.isArray(a)&&a.reason||null,this._source=a&&!Array.isArray(a)&&a.source||null,this._error=null,this._loading=!1,n?this.render():this._renderFreshness();return}catch(t){if(e!==this._api)return;this._error||(this._error=`Failed to load runs: ${t.message}`)}finally{this._loading=!1}this.render()}async _cancelRun(e){try{await this._api._post(`/api/v2/runs/${e}/cancel`),await this._loadData()}catch(t){this._error=`Cancel failed: ${t.message}`,this.render()}}async _replayRun(e){try{await this._api._post(`/api/v2/runs/${e}/replay`),await this._loadData()}catch(t){this._error=`Replay failed: ${t.message}`,this.render()}}_escapeHtml(e){return e?String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;"):""}_getStyles(){return`
+    `,this._bindEvents()}};customElements.get("loki-rarv-timeline")||customElements.define("loki-rarv-timeline",be);function xt(d){if(!d||typeof d!="object")return null;let e=d.freshness_s;return typeof e!="number"||!Number.isFinite(e)||e<0?null:e}function _t(d){if(!Array.isArray(d))return null;let e=null;for(let t of d){let i=xt(t);i!==null&&(e===null||i<e)&&(e=i)}return e}function yt(d={}){let{payload:e=null,receivedAtMs:t=null,nowMs:i=Date.now(),staleAfterS:a=120}=d,s=xt(e),r=null,o="none";return s!==null?(r=s,o="server"):typeof t=="number"&&Number.isFinite(t)&&(r=Math.max(0,Math.floor((i-t)/1e3)),o="client"),{known:r!==null,ageS:r,source:o,isStale:r===null?null:r>=a,staleAfterS:a}}function ti(d){if(!d||!d.known||typeof d.ageS!="number")return"unknown";let e=d.ageS;return e<60?`${e}s ago`:e<3600?`${Math.floor(e/60)}m ago`:e<86400?`${Math.floor(e/3600)}h ago`:`${Math.floor(e/86400)}d ago`}function Ze(d){if(!d||!d.known)return"Data age unknown";let e=d.source==="client"?" (receive time)":"",t=d.isStale?" - STALE":"";return`Updated ${ti(d)}${e}${t}`}var wt={running:{color:"var(--loki-green, #22c55e)",bg:"var(--loki-green-muted, rgba(34, 197, 94, 0.15))",label:"Running"},completed:{color:"var(--loki-blue, #3b82f6)",bg:"var(--loki-blue-muted, rgba(59, 130, 246, 0.15))",label:"Completed"},failed:{color:"var(--loki-red, #ef4444)",bg:"var(--loki-red-muted, rgba(239, 68, 68, 0.15))",label:"Failed"},cancelled:{color:"var(--loki-yellow, #eab308)",bg:"var(--loki-yellow-muted, rgba(234, 179, 8, 0.15))",label:"Cancelled"},pending:{color:"var(--loki-text-muted, #939084)",bg:"var(--loki-bg-tertiary, #ECEAE3)",label:"Pending"},queued:{color:"var(--loki-text-muted, #939084)",bg:"var(--loki-bg-tertiary, #ECEAE3)",label:"Queued"},building:{color:"var(--loki-green, #22c55e)",bg:"var(--loki-green-muted, rgba(34, 197, 94, 0.15))",label:"Building"},bootstrap:{color:"var(--loki-green, #22c55e)",bg:"var(--loki-green-muted, rgba(34, 197, 94, 0.15))",label:"Bootstrap"},complete:{color:"var(--loki-blue, #3b82f6)",bg:"var(--loki-blue-muted, rgba(59, 130, 246, 0.15))",label:"Completed"},stopped:{color:"var(--loki-yellow, #eab308)",bg:"var(--loki-yellow-muted, rgba(234, 179, 8, 0.15))",label:"Stopped"},paused:{color:"var(--loki-yellow, #eab308)",bg:"var(--loki-yellow-muted, rgba(234, 179, 8, 0.15))",label:"Paused"},unknown:{color:"var(--loki-text-muted, #939084)",bg:"var(--loki-bg-tertiary, #ECEAE3)",label:"Unknown"}};function ii(d,e,t){let i=d;if(i==null&&e){let l=new Date(e).getTime();i=(t?new Date(t).getTime():Date.now())-l}if(i==null||i<0)return"--";if(i<1e3)return`${i}ms`;let a=Math.floor(i/1e3);if(a<60)return`${a}s`;let s=Math.floor(a/60),r=a%60;if(s<60)return`${s}m ${r}s`;let o=Math.floor(s/60),n=s%60;return`${o}h ${n}m`}function ai(d){if(!d)return"--";try{return new Date(d).toLocaleString([],{month:"short",day:"numeric",hour:"2-digit",minute:"2-digit"})}catch{return String(d)}}var ke=class extends v{static get observedAttributes(){return["api-url","project-id","theme"]}constructor(){super(),this._loading=!1,this._error=null,this._api=null,this._runs=[],this._pollInterval=null,this._lastDataHash=null,this._emptyReason=null,this._source=null,this._freshPayload=null,this._changedAtMs=null}_freshness(){let e=t=>{if(!t)return!1;if(t.current===!0)return!0;let i=String(t.status||"").toLowerCase();return i==="running"||i==="in_progress"||i==="active"};return yt({payload:this._freshPayload,receivedAtMs:this._changedAtMs,staleAfterS:this._runs.some(e)?void 0:1/0})}_renderFreshness(){let e=this.shadowRoot&&this.shadowRoot.getElementById("freshness");if(!e)return;let t=this._freshness();e.className=`freshness ${t.known?t.isStale?"is-stale":"":"is-unknown"}`,e.dataset.source=t.source,e.dataset.stale=t.isStale===null?"unknown":String(t.isStale),e.textContent=Ze(t)}get projectId(){let e=this.getAttribute("project-id");return e?parseInt(e,10):null}set projectId(e){e!=null?this.setAttribute("project-id",String(e)):this.removeAttribute("project-id")}connectedCallback(){super.connectedCallback(),this._setupApi(),this._loadData(),this._startPolling()}disconnectedCallback(){super.disconnectedCallback(),this._stopPolling()}attributeChangedCallback(e,t,i){t!==i&&(e==="api-url"&&this._api&&(this._api=h({baseUrl:i}),this._loadData()),e==="project-id"&&this._loadData(),e==="theme"&&this._applyTheme())}_setupApi(){let e=this.getAttribute("api-url")||window.location.origin;this._api=h({baseUrl:e})}_startPolling(){this._poll=b({loadFn:()=>this._loadData(),intervalMs:5e3,element:this,immediate:!1})}_stopPolling(){this._poll&&(this._poll.stop(),this._poll=null)}async _loadData(){let e=this._api;try{let t=this.projectId,i=t!=null?`?project_id=${t}`:"",a=await e._get(`/api/v2/runs${i}`);if(e!==this._api)return;let s=a?.runs||a||[],r=Array.isArray(s)?s:[];this._freshPayload=a&&typeof a=="object"&&!Array.isArray(a)&&"freshness_s"in a?a:{freshness_s:_t(r)};let o=JSON.stringify(s),n=o!==this._lastDataHash||!!this._error;n&&(this._lastDataHash=o,this._runs=r,this._changedAtMs=Date.now()),this._emptyReason=a&&!Array.isArray(a)&&a.reason||null,this._source=a&&!Array.isArray(a)&&a.source||null,this._error=null,this._loading=!1,n?this.render():this._renderFreshness();return}catch(t){if(e!==this._api)return;this._error||(this._error=`Failed to load runs: ${t.message}`)}finally{this._loading=!1}this.render()}async _cancelRun(e){try{await this._api._post(`/api/v2/runs/${e}/cancel`),await this._loadData()}catch(t){this._error=`Cancel failed: ${t.message}`,this.render()}}async _replayRun(e){try{await this._api._post(`/api/v2/runs/${e}/replay`),await this._loadData()}catch(t){this._error=`Replay failed: ${t.message}`,this.render()}}_escapeHtml(e){return e?String(e).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;"):""}_getStyles(){return`
       :host {
         display: block;
       }

package/docs/LOOP-HARNESS-AUDIT.md

@@ -0,0 +1,631 @@
+# Loop harness audit, and one proposed measurement slice
+
+Audit only. No runtime behaviour is changed by this document, and the proposal
+at the end is read-only by construction.
+
+Every figure here was measured against the working tree at `4d8625bb`
+(v9.12.5) on 2026-08-04. Commands are included so each can be re-run rather
+than trusted.
+
+## What already exists
+
+### Structured traces
+
+`.loki/events.jsonl` is the trace surface, written by `emit_event_json`
+(`autonomy/run.sh:2435`) with a UTC timestamp and arbitrary `key=value` pairs.
+**26 distinct event types** are emitted:
+
+```
+agent_prompt              budget_exceeded            budget_warning
+capability_degraded       code_review_complete       code_review_council_complete
+code_review_*_oversized   code_review_start          dashboard_crash
+gate_stuck                iteration_complete         iteration_start
+managed_agents_fallback   managed_review_council_ok  phase_change
+policy_denied             provider_failover          provider_recovery
+review_verification_failed session_end               session_start
+stage_complete            task_completion_claim      watchdog_alert
+```
+
+```bash
+grep -ohE 'emit_event_json "[a-z_]+"' autonomy/run.sh | sort -u
+```
+
+### Verifier surface
+
+Gate functions in `autonomy/run.sh`:
+
+```
+_evidence_gate_and_surface     _invariant_gate_and_surface
+_semantic_gate_and_surface     _loki_supervised_completion_gates_pass
+gate_failure_disposition       build_gate_escalation_context
+run_doc_quality_gate           run_magic_debate_gate
+```
+
+Plus the 3-reviewer blind council, whose completion is traced by
+`code_review_complete` and `code_review_council_complete`.
+
+## The gap, stated precisely
+
+**The verifiers run, but they do not record what the directive asks for.**
+
+`code_review_complete` carries exactly three fields:
+
+```
+review_id=<id>  source=managed  iteration=<n>
+```
+
+`review_verification_failed` carries:
+
+```
+reason=<slug>  iteration=<n>  implementation_retry=<bool>
+```
+
+Neither carries any of:
+
+| Field the directive asks for | Emitted today |
+|---|---|
+| eligibility (did this verifier apply?) | no |
+| deterministic criterion | no |
+| retry cap / timeout cap | no |
+| latency | no |
+| tokens | no |
+| cash cost | no |
+| verdict | partial (failure reason only) |
+| changed the terminal outcome? | no |
+| false-positive review | no |
+| rollback switch | no |
+
+The `_evidence_gate_and_surface`, `_invariant_gate_and_surface` and
+`_semantic_gate_and_surface` functions emit **nothing structured at all** --
+grepping their bodies for `emit|json|cost|latency|duration|verdict` returns no
+matches.
+
+So a loop-harness manifest cannot be *derived* from today's traces. It would
+have to be *fabricated*, which is the failure mode this codebase treats as
+worse than an absent measurement.
+
+### Why that matters more than it sounds
+
+This session produced a concrete example of the cost. A gate false positive
+(mock-integrity firing on `require.resolve` + `spawnSync`) made first-pass
+completion impossible for every npm user, and it was invisible until someone
+ran the real thing. With per-verifier records carrying `verdict`,
+`changed_terminal_outcome` and `false_positive_reviewed`, that class shows up
+as a measurement rather than a field report.
+
+## Other audit axes, briefly
+
+**Memory / skills / prompts.** The main-loop prompt is assembled in memory and
+never persisted (`build_prompt`, `autonomy/run.sh:8987`), so prompt-version
+attribution is not currently possible. Review prompts *are* persisted
+(`run.sh:14700`). Any prompt-versioning proposal has to start by making the
+main prompt observable, and that is a runtime change -- out of scope here.
+
+**Context compression.** The prompt splits at `[CACHE_BREAKPOINT]` into a
+cache-stable prefix and a volatile tail. That is a real, already-shipped
+compression discipline. It is not currently measured per-run.
+
+**Model routing by quality/latency/cost.** `get_rarv_tier()` maps iteration to
+model tier. The mapping is deterministic and readable; what is absent is any
+*recorded* per-call association between the tier chosen and the outcome it
+produced, which is what a routing evaluation would need.
+
+## Proposal: `loop-harness-v1`, read-only, one slice
+
+**Do not add a loop. Do not change runtime architecture.** The single coherent
+reversible slice is a **report over traces that already exist**, plus the
+smallest instrumentation that makes the report non-vacuous.
+
+### Phase A -- report only, zero runtime change
+
+`tools/loop-harness-report.py`, a read-only reader in the shape of the existing
+`api_*` modules:
+
+- reads `.loki/events.jsonl`
+- emits one row per verifier invocation it can actually observe
+- **every field it cannot derive reads UNKNOWN, never a default**
+- carries the standard envelope: `source`, `freshness_s`, `reason`
+- exits 3 (nothing to check) on a workspace with no verifier events
+
+This is honest on day one: most columns read UNKNOWN, and the report says so.
+That is the correct starting point -- it makes the gap visible and measurable
+rather than asserting a completeness that does not exist.
+
+### Phase B -- instrumentation, only where A proves it is needed
+
+Add the missing fields to the three gate functions and the council completion
+event. Each addition is one `emit_event_json` call with named fields, and each
+is independently revertable.
+
+Phase B is **not** proposed for adoption yet: it changes runtime behaviour, and
+the directive says keep runtime unchanged unless an evidenced deterministic
+requirement justifies it. Phase A produces that evidence.
+
+### What would make this worth automating
+
+The directive's bar is the right one: automate only when offline replay and
+online outcomes prove quality-adjusted lift exceeds latency and cost. Phase A
+cannot clear that bar and does not try -- it is the measurement that would let
+a later proposal clear it.
+
+## Rollback
+
+Phase A adds one file under `tools/` and touches no runtime path. Rollback is
+deleting it. Nothing in `.loki/` is written, so there is no state to unwind.
+
+## The four surfaces, measured
+
+| Surface | State | Evidence |
+|---|---|---|
+| Composable core-agent loop | present, modular | `run_autonomous()` + `get_rarv_tier()` + `build_prompt()` are separable functions |
+| Bounded verification loop | present, **unmeasured** | 3 gate fns emit 0 structured records; `code_review_complete` carries 3 fields |
+| Real-system event-driven loop | present, **partial contract** | `autonomy/trigger-server.py`: auth 7, timeout 12, idempotency 4, retry 2 -- but dedupe 0, dead-letter 0, backpressure 0 |
+| Self-improvement / hill-climbing | present, **not wired to traces** | `LOKI_AUTO_LEARNINGS` appears 0 times in `run.sh`; the TS route has it (`counter_evidence.ts`, `episode_bridge.ts`) |
+
+```bash
+for p in idempot dedupe dead.letter backpressure retry timeout auth; do
+  printf '%-16s %s\n' "$p" "$(grep -ciE "$p" autonomy/trigger-server.py)"
+done
+```
+
+### The three exact gaps
+
+1. **Verifier records carry no cost, latency, criterion, or effect.** This is
+   the blocker for every downstream ask -- a marginal-lift comparison, a
+   promotion rule, and a canary decision all need per-verifier cost and
+   outcome, and none is emitted.
+
+2. **The trigger contract is three properties short.** Auth, timeout,
+   idempotency and bounded retry exist. Dedupe, dead-letter state and
+   backpressure do not. An idempotent trigger without dedupe still processes a
+   duplicate delivery; without dead-letter state a poisoned message retries to
+   its cap and vanishes.
+
+3. **The learnings loop is route-asymmetric.** `LOKI_AUTO_LEARNINGS` is
+   documented as default-on in the Bun runner and is absent from `run.sh`, so
+   the bash route contributes nothing to hill-climbing. Any trace-driven
+   improvement claim measured on one route does not transfer to the other.
+
+## Why architecture stays unchanged
+
+Every downstream ask in the directive -- matched online cohorts, marginal-lift
+per verifier, a promotion rule, a canary window -- is **downstream of
+measurement that does not exist**. Building a manifest, a cohort comparison or
+an automation rule on top of absent instrumentation would produce numbers with
+no referent.
+
+The cheapest surface that changes this is Phase A: a read-only reader that
+reports what IS recorded and names what is not. It is implemented and tested
+(`tools/loop-harness-report.py`, 8 assertions, both fabrication modes
+mutation-tested). Against this repo's own trace it reads 776 records, finds no
+verifier events, and exits 3 with a reason rather than printing an empty table
+that reads as a clean run.
+
+**The smallest reversible next step** is adopting Phase A and running it over
+a real build's trace. That yields the first honest per-verifier row set, and
+its UNKNOWN columns are the evidenced requirement that would justify Phase B
+instrumentation -- which is a runtime change and is deliberately not proposed
+until that evidence exists.
+
+## Correction: the six named axes, measured
+
+The first pass treated routing as unmeasured. That was wrong, and the correction
+matters because it changes which work is worth doing.
+
+| Axis | State | Evidence |
+|---|---|---|
+| Memory / retrieval | wired into the loop | 13 references in `run.sh` |
+| Tool descriptions | present | 13 in `mcp/server.py` |
+| Context compression | shipped, unmeasured per-run | `[CACHE_BREAKPOINT]` prefix split |
+| Prompts | **not attributable** | main prompt in memory only (`run.sh:8987`); review prompts persisted (`:14700`) |
+| **Quality/latency/cost routing** | **fully recorded** | see below |
+| Verifier records | **absent** | unchanged from the first pass |
+
+### Routing is already instrumented
+
+`.loki/metrics/efficiency/` records carry:
+
+```
+model  provider  phase  iteration  status  timestamp
+cost_usd  duration_ms
+input_tokens  output_tokens  cache_read_tokens  cache_creation_tokens
+```
+
+`LOKI_CURRENT_MODEL` holds the EXACT dispatched `--model` value, exported after
+every mutation (opus-pin, `LOKI_MAX_TIER` clamp, mid-flight override), so the
+recorded model is the one actually used. `run.sh:7834` documents the bug that
+made this necessary: hardcoding the development-tier default mislabeled every
+non-development iteration and "made the model-equivalence bench unfalsifiable."
+
+`record_is_measured()` (`autonomy/lib/efficiency_cost.py:81`) is the single
+definition of measured, and its docstring records why a second copy is
+forbidden: "the four surfaces that once rendered an unmeasured run as $0.00
+each had their own idea of what counted as measured."
+
+`dashboard/api_runs.py` already reads these (22 references).
+
+**So a quality/latency/cost routing evaluation is possible today** -- model,
+cost, latency and tokens are all recorded per iteration with an honesty
+predicate. What is missing is not instrumentation but a *comparison*: no
+baseline pins a model choice to an outcome.
+
+### The caveat, and why it is smaller than it looked
+
+Efficiency records are WIPED at run start (`run.sh:6212`), which is why a
+historical run reports `cost_usd: None` and why this workspace holds zero
+records.
+
+But receipts survive, and they DO carry the model. `proof-generator.py:627`
+resolves it through four sources -- an observed value, `LOKI_CURRENT_MODEL`,
+`LOKI_SESSION_MODEL`, `SESSION_MODEL` -- then the execution policy's
+`sdk_id`/`alias`, and only then returns the string `"unavailable"`. It never
+guesses.
+
+Verified end to end: generating a receipt with `LOKI_CURRENT_MODEL=
+claude-sonnet-5` yields `provider: {"name": "claude", "model":
+"claude-sonnet-5"}`. The nine archived receipts read `"model": "unavailable"`
+with `cost_usd: None` because they predate the efficiency wiring, not because
+the mechanism is missing.
+
+**So the cross-run corpus for a routing evaluation is the receipt archive**,
+which retains model, provider, cost, tokens and wall clock per run. No new
+instrumentation is required.
+
+### What this changes about the proposal
+
+Verifier records remain the real gap, unchanged. But routing does NOT need
+Phase B instrumentation -- it needs an evaluation over data that already
+exists. That is a cheaper and better-evidenced next step than instrumenting
+the gates, and it is squarely inside the directive's "improve routing before
+touching architecture."
+
+## The routing evaluation: blocked on corpus, not on code
+
+Having established that receipts retain the model, the obvious next step is the
+evaluation itself. It cannot be built yet, and the reason is worth recording
+precisely.
+
+Measured across the whole archive:
+
+```
+receipts:            9
+models:              {"unavailable": 9}
+with measured cost:  0
+```
+
+Every receipt reads `"model": "unavailable"` and `cost_usd: None`. They were
+written Jul 26 and Jul 31; the efficiency wiring that populates both landed
+later. The mechanism is proven to work -- generating a receipt with
+`LOKI_CURRENT_MODEL` set captures the exact model -- but no archived run
+exercised it.
+
+**So a routing evaluation today would have zero rows to compare.** Building it
+now produces a reader with nothing to read, and any number it reported would
+be derived from a single degenerate cohort.
+
+That is a corpus problem, not a code problem, and the fix is not more code: it
+is running builds and letting the archive fill. Each real `loki start` from
+here produces a receipt carrying model, provider, cost, tokens and wall clock.
+The evaluation becomes worth writing once the archive holds more than one
+distinct model.
+
+### What this means for sequencing
+
+The directive asks for verifier lift to exceed latency and cost on baseline
+plus ambitious E2E plus online outcomes. That bar cannot be cleared from a
+corpus of nine degenerate rows, and no amount of tooling changes it.
+
+The honest ordering is therefore:
+
+1. accumulate receipts from real runs (no code required)
+2. write the evaluation once two or more distinct models appear
+3. only then consider verifier instrumentation, which is the one gap where
+   the data genuinely does not exist at any volume
+
+Steps 1 and 2 need no runtime change. Step 3 remains unproposed.
+
+## Step 1 executed: the corpus has its first real row
+
+Rather than leave "accumulate receipts" as advice, one real `loki start` was
+run against a minimal spec. It completed exit 0, built working code (its own
+6 tests pass), and wrote a receipt carrying exactly what a routing evaluation
+needs:
+
+```
+provider     {"name": "claude", "model": "sonnet"}     <- not "unavailable"
+cost_usd     1.3828        input/output tokens  48 / 7290
+iterations   1 succeeded, 0 failed
+duration_ms  128000        wall_clock_sec       576
+base_sha     ef1efe909750  head_sha             5a727616da91
+```
+
+Contrast with the nine archived receipts, all `"model": "unavailable"` and
+`cost_usd: None`. The mechanism was never broken; those runs simply predate
+it.
+
+`iterations.attribution` is worth noting for any lift measurement: it splits
+cost into `progress` and `rework`, and states its own basis -- "rework counts
+FAILED iterations only; a completed iteration forced to repeat by a gate is
+counted as progress, so rework is a floor". That is a self-describing lower
+bound rather than an unqualified number.
+
+### The verdict reads FAILED, correctly
+
+`receipts_report` returns FAILED with `measured: True` and the real cost. The
+reason is diff drift: 11 files / +494 recorded, more now. The cause was
+verified by timestamp -- only `run.log` (still being appended) and
+`.pytest_cache/` from the verification run itself changed after signing.
+
+That is the verifier working. A receipt signed at time T and inspected at
+T+delta, with files touched in between, SHOULD fail. The lesson for a future
+evaluation harness: read receipts without running anything inside the
+workspace, or the act of measuring invalidates what is measured.
+
+### Where the corpus stands
+
+Two distinct models are needed before a comparison means anything. The archive
+now holds one real row (`sonnet`) plus nine degenerate ones. The evaluation
+remains unwritten, and that is still the honest position -- but step 1 is no
+longer hypothetical.
+
+## Step 2: two models, and the first real comparison
+
+A second real run, pinned with `LOKI_SESSION_MODEL=opus`, gives the corpus its
+second distinct model. Both runs used the same shape of task (a small pure
+helper plus its test) and both succeeded in one iteration.
+
+| | sonnet | opus |
+|---|---|---|
+| cost_usd | 1.3828 | **0.6823** |
+| output tokens | 7290 | **4446** |
+| wall_clock_sec | 576 | **472** |
+| progress duration_ms | 128000 | **71000** |
+| iterations | 1 succeeded | 1 succeeded |
+
+**This is two data points, not a finding.** Two runs of two different specs
+cannot separate model effect from task effect, and the directive's bar --
+lift exceeding latency and cost across baseline, ambitious E2E, and online
+cohorts -- is nowhere near cleared. Recorded because it is the first
+comparison the corpus has ever supported, and because the shape is now
+proven: the fields needed for a routing evaluation arrive populated and
+measured on every real run.
+
+## A real defect the corpus work surfaced
+
+Both receipts read FAILED on diff drift. The first time, the cause was my own
+verification run writing `.pytest_cache/`. The second time I deliberately
+touched nothing, and it STILL failed. The only file newer than the receipt:
+
+```
+run.log
+```
+
+**A run whose stdout is redirected into its own workspace invalidates its own
+receipt.** The log keeps growing after the receipt is signed, so the recorded
+diff no longer matches the tree. Any user who runs
+`loki start ./prd.md > run.log` inside the workspace gets a receipt that
+cannot verify, through no fault of their own.
+
+### Scoping that claim honestly
+
+The first write-up called this a usability trap users would hit. Checking
+rather than assuming shrinks it:
+
+- the documented invocation is plain `loki start prd.md` (README:333, 342,
+  360) with NO redirection, so an interactive user never creates `run.log` in
+  the workspace
+- the runtime has no concept of its own log path -- grepping `run.sh` and the
+  CLI for `LOKI_RUN_LOG`, `RUN_LOG=` or a log-path helper returns nothing
+- `> run.log` appears nowhere in the docs; it was MY invocation choice for a
+  backgrounded run
+
+So this is not a shipped defect users are hitting. It is a real constraint on
+anyone who captures stdout inside the workspace -- CI harnesses, scripted
+runs, and future evaluation tooling -- and that includes the routing
+evaluation this audit is building toward.
+
+`workspace_diff.py:28` already has an `_excluded()` predicate (currently
+`.loki/` only), so excluding a known log path would be a one-line change. It
+is NOT proposed, for a specific reason: excluding by the literal name
+`run.log` would silently drop a user's own file of that name from the receipt,
+which is a worse failure than the one being fixed. A correct fix needs the
+runtime to know its own log path, and that is a runtime change with no
+evidenced user demand behind it.
+
+The durable output is the constraint, not a patch: **an evaluation harness
+must not write inside the workspace it measures**, including redirecting the
+run's own stdout there. Recorded so it is not rediscovered a third time.
+
+## Correction: two of the three trigger gaps were my grep, not the code
+
+The audit claimed `autonomy/trigger-server.py` was three properties short:
+dedupe 0, dead-letter 0, backpressure 0. Two of those were false negatives from
+searching for the wrong words.
+
+**Dedupe exists** and is well built. `Dispatcher.seen_delivery()` keeps recent
+GitHub delivery ids in a lock-guarded bounded `OrderedDict`. It deliberately
+does NOT refresh recency on a duplicate, and the code says why: "a flood of one
+valid (authenticated) duplicate id could keep it pinned and evict up to
+dedup_max genuinely-recent ids, letting real redeliveries slip through."
+
+Verified by executing the method directly:
+
+```
+first delivery abc   -> False   (new)
+repeat delivery abc  -> True    (deduped)
+absent header ""     -> False   (never deduplicated, falls through)
+after eviction       -> False   (bounded, evicts oldest first)
+```
+
+**Backpressure exists.** The dispatcher holds a bounded `queue.Queue`, catches
+`queue.Full`, and sheds load with 503 -- the module docstring states it at line
+12. My earlier check used a malformed `-E` alternation and returned 0 for terms
+plainly present in the file (`queue_size` alone appears 7 times).
+
+**Dead-letter state is the one that is genuinely absent.** No DLQ, no failed-job
+retention: a job that exhausts its retries is dropped.
+
+### The lesson, which is the same one twice
+
+`phases` was reported missing from `loki proof --help` by a grep that could not
+see it; dedupe was reported absent by a grep looking for the wrong noun. Both
+times the code was fine and the measurement was broken.
+
+An absence found by grep is a hypothesis, not a finding. It has to be confirmed
+by reading the code or executing it -- exactly the standard this audit applies
+to the runtime, now applied to the audit itself.
+
+### Revised trigger contract state
+
+| Property | State |
+|---|---|
+| authentication | present |
+| timeout | present |
+| bounded retry | present |
+| idempotency | present |
+| **dedupe** | **present** (verified by execution) |
+| **backpressure** | **present** (bounded queue, 503 shed) |
+| dead-letter state | absent |
+
+One property short, not three. A trigger-to-run-to-receipt path is therefore
+much closer to complete than the audit claimed, and the remaining gap is
+narrow: a job that exhausts retries vanishes without a record.
+
+## Third correction: the last "gap" is smaller still
+
+Applying the new standard to my own remaining claim -- dead-letter state absent
+-- turned up a near-miss worth recording, because the mistake is instructive.
+
+Reading `_worker` (trigger-server.py:425) shows `dispatch_event` wrapped in
+`try/finally` with NO `except`. That looks like a serious defect: one handler
+exception would kill the worker thread, and with `DEFAULT_WORKERS = 4`, four
+failures would silently drain all capacity while the server kept returning 200.
+
+I reproduced exactly that behaviour and was ready to report it. **The
+reproduction was wrong**: it used a stub that raised, not the real
+`dispatch_event`.
+
+The real function catches everything (`trigger-server.py:356`):
+
+```python
+except Exception as e:  # defensive: never let a worker die on bad input
+    logging.exception("Handler for %s raised: %s", event_type, e)
+    summary, status = None, "error"
+```
+
+Verified against the actual code: `dispatch_event` returns `(None, "error")`
+without raising, logs the traceback, and the daemon thread count is unchanged
+(1 before, 1 after). The worker survives, and the guard is placed at the callee
+precisely so the bare `try/finally` in the loop is safe.
+
+### What that leaves
+
+A failed job IS recorded -- `logging.exception` plus `log_event(..., status)`.
+So "dead-letter state absent" overstates it too. What is genuinely missing is a
+*queryable* record: the failure lands in logs, not in a structure something
+could retry from or report on.
+
+That is a real but narrow gap, and it is not worth a runtime change on this
+evidence.
+
+### Score on my own audit
+
+Of the three trigger gaps originally claimed:
+
+- dedupe -- **present**, found by grepping the wrong noun
+- backpressure -- **present**, found by a malformed regex
+- dead-letter -- **overstated**; failures are logged, just not queryable
+
+And one defect I nearly reported was an artifact of testing my own mock.
+
+Four measurement errors in one audit section. The corrective standard, now
+demonstrated three times: **an absence is a hypothesis until the real code is
+read or executed** -- and a reproduction must exercise the real function, not
+a stand-in shaped like it.
+
+## Clean checkpoint: 5605deca, all 19 jobs green
+
+Recorded per the gate discipline: the trigger-contract correction reached
+`Tests@5605deca: completed / success`, 19 of 19 jobs, zero failures. No run was
+superseded to get there.
+
+### Where the four surfaces actually stand, after all corrections
+
+| Surface | State | Confidence |
+|---|---|---|
+| Composable core-agent | modular, separable functions | read |
+| Bounded verification | verifiers run; records carry no cost/latency/criterion/effect | read + grep |
+| Event-driven trigger | auth, timeout, retry, idempotency, dedupe, backpressure all present; failures logged but not queryable | **executed** |
+| Self-improvement | `LOKI_AUTO_LEARNINGS` on the TS route only, absent from `run.sh` and the CLI | grep, unverified |
+
+The confidence column matters more than the state column. Everything I checked
+by execution survived scrutiny; three of the four things I checked by grep did
+not.
+
+### The smallest next slice, and why it is not code
+
+The directive's bar for any verifier change is a matched ablation showing lift
+above p95 latency and cost, on the same task, across seeds. Nothing in this
+repo can currently produce that number:
+
+- verifier records carry no cost or latency at all, so the denominator is
+  missing
+- the routing corpus holds two real rows from two DIFFERENT specs, which is
+  explicitly excluded ("do not infer this from different tasks or one seed")
+
+So the smallest honest next slice is **the same spec run twice under two
+models**, which is the minimum a matched ablation admits. That is one command
+and no code. Until it exists, any harness or eval built on top would be
+measuring a corpus that cannot support the claim.
+
+The one surface still unverified by execution is self-improvement: the
+`LOKI_AUTO_LEARNINGS` asymmetry was found by grep, and grep has been wrong
+three times in this audit. It should be confirmed by running before it is
+treated as a finding.
+
+## The matched pair, executed
+
+The previous entry said the smallest honest next step was the same spec run
+twice under two models. That has now been done: identical `prd.md` (byte-for-byte,
+`diff -q` verified), identical iteration cap, run SEQUENTIALLY so CPU contention
+could not confound latency, logs written OUTSIDE each workspace so the run could
+not invalidate its own receipt.
+
+| | sonnet | opus |
+|---|---|---|
+| cost_usd | 0.7177 | **0.6257** |
+| output tokens | 3658 | 3547 |
+| wall_clock_sec | 458 | **406** |
+| progress duration_ms | 65000 | 67000 |
+| iterations | 1 of 1 succeeded | 1 of 1 succeeded |
+| produced code | 1 test passing | 1 test passing |
+
+Both arms solved the task. On this pair, opus was 12.8% cheaper and 11% faster
+in wall clock, while taking marginally longer in measured progress duration --
+the wall/duration split suggests the difference sits in orchestration overhead,
+not model latency.
+
+### What this does and does not license
+
+It **does** establish that the corpus can now produce a matched comparison: same
+task, same budget, controlled ordering, both outcomes verified by running the
+produced tests rather than trusting the receipt.
+
+It **does not** clear the directive's bar. That requires lift above p95 latency
+and cost across seeds, and this is n=1 per arm. A single pair cannot separate
+model effect from run-to-run variance, and the two prior unmatched runs
+(sonnet $1.3828, opus $0.6823) differ from these by more than the arms differ
+from each other -- which is itself the evidence that one pair proves nothing
+about the population.
+
+The honest reading: the *method* is now demonstrated end to end. The *finding*
+needs repetition, and repetition is provider spend, which is a founder call.
+
+### Method notes worth keeping
+
+Three procedural constraints were learned by getting them wrong first:
+
+1. log outside the workspace, or the run invalidates its own receipt
+2. run arms sequentially, or contention confounds the latency column
+3. verify the produced artifact by executing it -- a receipt records what a run
+   claimed to do, not whether the code works

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var u_=Object.create;var{getPrototypeOf:p_,defineProperty:eK,getOwnPropertyNames:d_}=Object;var c_=Object.prototype.hasOwnProperty;function l_(Z){return this[Z]}var i_,a_,s_=(Z,X,Q)=>{var Y=Z!=null&&typeof Z==="object";if(Y){var J=X?i_??=new WeakMap:a_??=new WeakMap,z=J.get(Z);if(z)return z}Q=Z!=null?u_(p_(Z)):{};let K=X||!Z||!Z.__esModule?eK(Q,"default",{value:Z,enumerable:!0}):Q;for(let $ of d_(Z))if(!c_.call(K,$))eK(K,$,{get:l_.bind(Z,$),enumerable:!0});if(Y)J.set(Z,K);return K};var HQ=(Z,X)=>()=>(X||Z((X={exports:{}}).exports,X),X.exports);var n_=(Z)=>Z;function o_(Z,X){this[Z]=n_.bind(null,X)}var l0=(Z,X)=>{for(var Q in X)eK(Z,Q,{get:X[Q],enumerable:!0,configurable:!0,set:o_.bind(X,Q)})};var p=(Z,X)=>()=>(Z&&(X=Z(Z=0)),X);var t0=import.meta.require;var kO={};l0(kO,{lokiDir:()=>j0,homeLokiDir:()=>R4,findRepoRootForVersion:()=>X$,REPO_ROOT:()=>i0});import{resolve as n7,dirname as Z$}from"path";import{fileURLToPath as r_}from"url";import{existsSync as UQ}from"fs";import{homedir as t_}from"os";function e_(){let Z=RO;for(let X=0;X<6;X++){if(UQ(n7(Z,"VERSION"))&&UQ(n7(Z,"autonomy/run.sh")))return Z;let Q=Z$(Z);if(Q===Z)break;Z=Q}return n7(RO,"..","..","..")}function X$(Z){let X=Z;for(let Q=0;Q<6;Q++){if(UQ(n7(X,"VERSION"))&&UQ(n7(X,"autonomy/run.sh")))return X;let Y=Z$(X);if(Y===X)break;X=Y}return n7(Z,"..","..","..")}function j0(){return process.env.LOKI_DIR??n7(process.cwd(),".loki")}function R4(){return n7(t_(),".loki")}var RO,i0;var H8=p(()=>{RO=Z$(r_(import.meta.url));i0=e_()});import{readFileSync as Zf}from"fs";import{resolve as Xf,dirname as Qf}from"path";import{fileURLToPath as Yf}from"url";function h3(){if(h5!==null)return h5;let Z="9.12.4";if(typeof Z==="string"&&Z.length>0)return h5=Z,h5;try{let X=Qf(Yf(import.meta.url)),Q=X$(X);h5=Zf(Xf(Q,"VERSION"),"utf-8").trim()}catch{h5="unknown"}return h5}var h5=null;var BQ=p(()=>{H8()});var bO={};l0(bO,{runOrThrow:()=>Mf,run:()=>E0,readStreamCapped:()=>NQ,commandVersion:()=>wf,commandExists:()=>X9,ShellError:()=>Q$,MAX_STDOUT_BYTES:()=>yO});async function NQ(Z,X=yO){let Q=Z.getReader(),Y=new TextDecoder,J="",z=0;try{while(z<X){let{done:K,value:$}=await Q.read();if(K)break;if(!$)continue;if(z+=$.byteLength,z>X){let W=$.byteLength-(z-X);J+=Y.decode($.subarray(0,W),{stream:!0});break}J+=Y.decode($,{stream:!0})}J+=Y.decode()}finally{try{await Q.cancel()}catch{}Q.releaseLock()}return J}async function E0(Z,X={}){let Q=Bun.spawn({cmd:[...Z],stdout:"pipe",stderr:"pipe",env:X.env?{...process.env,...X.env}:process.env,cwd:X.cwd}),Y,J;if(X.timeoutMs&&X.timeoutMs>0)Y=setTimeout(()=>{try{Q.kill("SIGTERM")}catch{}J=setTimeout(()=>{try{Q.kill("SIGKILL")}catch{}},2000)},X.timeoutMs);try{let[z,K,$]=await Promise.all([NQ(Q.stdout),new Response(Q.stderr).text(),Q.exited]);return{stdout:z,stderr:K,exitCode:$}}finally{if(Y)clearTimeout(Y);if(J)clearTimeout(J)}}async function Mf(Z,X={}){let Q=await E0(Z,X);if(Q.exitCode!==0)throw new Q$(`command failed (${Q.exitCode}): ${Z.join(" ")}`,Q.exitCode,Q.stdout,Q.stderr);return Q}async function X9(Z){let X=Tf(Z),Q=await E0(["sh","-c",`command -v ${X}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function Tf(Z){if(!/^[A-Za-z0-9._/-]+$/.test(Z))throw Error(`refused to shell-escape suspect token: ${Z}`);return Z}async function wf(Z,X="--version"){if(!await X9(Z))return null;let Y=await E0([Z,X],{timeoutMs:5000});if(Y.exitCode!==0)return null;return((Y.stdout||Y.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var yO=16777216,Q$;var x9=p(()=>{Q$=class Q$ extends Error{message;exitCode;stdout;stderr;constructor(Z,X,Q,Y){super(Z);this.message=Z;this.exitCode=X;this.stdout=Q;this.stderr=Y;this.name="ShellError"}}});function o7(Z){return Cf?"":Z}var Cf,L0,F8,p0,KV0,a0,W8,Q9,v;var S6=p(()=>{Cf=(process.env.NO_COLOR??"").length>0;L0=o7("\x1B[0;31m"),F8=o7("\x1B[0;32m"),p0=o7("\x1B[1;33m"),KV0=o7("\x1B[0;34m"),a0=o7("\x1B[0;36m"),W8=o7("\x1B[1m"),Q9=o7("\x1B[2m"),v=o7("\x1B[0m")});import{existsSync as _f}from"fs";async function E7(){if(x4!==void 0)return x4;let Z="/opt/homebrew/bin/python3.12";if(_f(Z))return x4=Z,Z;let X=await X9("python3.12");if(X)return x4=X,X;let Q=await X9("python3");return x4=Q,Q}async function Y7(Z,X={}){let Q=await E7();if(!Q)return{stdout:"",stderr:"python3 not found",exitCode:127};return E0([Q,"-c",Z],X)}var x4;var r7=p(()=>{x9()});var ZL={};l0(ZL,{runStatus:()=>$h});import{existsSync as Y9,readFileSync as g3,readdirSync as iO,statSync as aO}from"fs";import{resolve as h8,basename as tf}from"path";import{homedir as ef}from"os";function sO(Z){let X=Math.trunc(Z);if(X>=1e6)return`${(Math.trunc(X/1e6*10)/10).toFixed(1)}M`;if(X>=1000)return`${(Math.trunc(X/1000*10)/10).toFixed(1)}K`;return String(X)}function nO(Z,X,Q){if(X===0)return null;let Y=Math.trunc(Z*100/X),J=Math.trunc(Z*LQ/X);if(J>LQ)J=LQ;let z=LQ-J,K=F8;if(Y>=80)K=L0;else if(Y>=50)K=p0;let $="=".repeat(Math.max(0,J))+" ".repeat(Math.max(0,z)),W=sO(Z),V=sO(X);return`  ${W8}${Q}${v} ${K}[${$}]${v} ${Y}% (${W} / ${V})`}async function Xh(){if(await X9("jq"))return!0;return process.stdout.write(`${L0}Error: jq is required but not installed.${v}
+var u_=Object.create;var{getPrototypeOf:p_,defineProperty:eK,getOwnPropertyNames:d_}=Object;var c_=Object.prototype.hasOwnProperty;function l_(Z){return this[Z]}var i_,a_,s_=(Z,X,Q)=>{var Y=Z!=null&&typeof Z==="object";if(Y){var J=X?i_??=new WeakMap:a_??=new WeakMap,z=J.get(Z);if(z)return z}Q=Z!=null?u_(p_(Z)):{};let K=X||!Z||!Z.__esModule?eK(Q,"default",{value:Z,enumerable:!0}):Q;for(let $ of d_(Z))if(!c_.call(K,$))eK(K,$,{get:l_.bind(Z,$),enumerable:!0});if(Y)J.set(Z,K);return K};var HQ=(Z,X)=>()=>(X||Z((X={exports:{}}).exports,X),X.exports);var n_=(Z)=>Z;function o_(Z,X){this[Z]=n_.bind(null,X)}var l0=(Z,X)=>{for(var Q in X)eK(Z,Q,{get:X[Q],enumerable:!0,configurable:!0,set:o_.bind(X,Q)})};var p=(Z,X)=>()=>(Z&&(X=Z(Z=0)),X);var t0=import.meta.require;var kO={};l0(kO,{lokiDir:()=>j0,homeLokiDir:()=>R4,findRepoRootForVersion:()=>X$,REPO_ROOT:()=>i0});import{resolve as n7,dirname as Z$}from"path";import{fileURLToPath as r_}from"url";import{existsSync as UQ}from"fs";import{homedir as t_}from"os";function e_(){let Z=RO;for(let X=0;X<6;X++){if(UQ(n7(Z,"VERSION"))&&UQ(n7(Z,"autonomy/run.sh")))return Z;let Q=Z$(Z);if(Q===Z)break;Z=Q}return n7(RO,"..","..","..")}function X$(Z){let X=Z;for(let Q=0;Q<6;Q++){if(UQ(n7(X,"VERSION"))&&UQ(n7(X,"autonomy/run.sh")))return X;let Y=Z$(X);if(Y===X)break;X=Y}return n7(Z,"..","..","..")}function j0(){return process.env.LOKI_DIR??n7(process.cwd(),".loki")}function R4(){return n7(t_(),".loki")}var RO,i0;var H8=p(()=>{RO=Z$(r_(import.meta.url));i0=e_()});import{readFileSync as Zf}from"fs";import{resolve as Xf,dirname as Qf}from"path";import{fileURLToPath as Yf}from"url";function h3(){if(h5!==null)return h5;let Z="9.12.6";if(typeof Z==="string"&&Z.length>0)return h5=Z,h5;try{let X=Qf(Yf(import.meta.url)),Q=X$(X);h5=Zf(Xf(Q,"VERSION"),"utf-8").trim()}catch{h5="unknown"}return h5}var h5=null;var BQ=p(()=>{H8()});var bO={};l0(bO,{runOrThrow:()=>Mf,run:()=>E0,readStreamCapped:()=>NQ,commandVersion:()=>wf,commandExists:()=>X9,ShellError:()=>Q$,MAX_STDOUT_BYTES:()=>yO});async function NQ(Z,X=yO){let Q=Z.getReader(),Y=new TextDecoder,J="",z=0;try{while(z<X){let{done:K,value:$}=await Q.read();if(K)break;if(!$)continue;if(z+=$.byteLength,z>X){let W=$.byteLength-(z-X);J+=Y.decode($.subarray(0,W),{stream:!0});break}J+=Y.decode($,{stream:!0})}J+=Y.decode()}finally{try{await Q.cancel()}catch{}Q.releaseLock()}return J}async function E0(Z,X={}){let Q=Bun.spawn({cmd:[...Z],stdout:"pipe",stderr:"pipe",env:X.env?{...process.env,...X.env}:process.env,cwd:X.cwd}),Y,J;if(X.timeoutMs&&X.timeoutMs>0)Y=setTimeout(()=>{try{Q.kill("SIGTERM")}catch{}J=setTimeout(()=>{try{Q.kill("SIGKILL")}catch{}},2000)},X.timeoutMs);try{let[z,K,$]=await Promise.all([NQ(Q.stdout),new Response(Q.stderr).text(),Q.exited]);return{stdout:z,stderr:K,exitCode:$}}finally{if(Y)clearTimeout(Y);if(J)clearTimeout(J)}}async function Mf(Z,X={}){let Q=await E0(Z,X);if(Q.exitCode!==0)throw new Q$(`command failed (${Q.exitCode}): ${Z.join(" ")}`,Q.exitCode,Q.stdout,Q.stderr);return Q}async function X9(Z){let X=Tf(Z),Q=await E0(["sh","-c",`command -v ${X}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function Tf(Z){if(!/^[A-Za-z0-9._/-]+$/.test(Z))throw Error(`refused to shell-escape suspect token: ${Z}`);return Z}async function wf(Z,X="--version"){if(!await X9(Z))return null;let Y=await E0([Z,X],{timeoutMs:5000});if(Y.exitCode!==0)return null;return((Y.stdout||Y.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var yO=16777216,Q$;var x9=p(()=>{Q$=class Q$ extends Error{message;exitCode;stdout;stderr;constructor(Z,X,Q,Y){super(Z);this.message=Z;this.exitCode=X;this.stdout=Q;this.stderr=Y;this.name="ShellError"}}});function o7(Z){return Cf?"":Z}var Cf,L0,F8,p0,KV0,a0,W8,Q9,v;var S6=p(()=>{Cf=(process.env.NO_COLOR??"").length>0;L0=o7("\x1B[0;31m"),F8=o7("\x1B[0;32m"),p0=o7("\x1B[1;33m"),KV0=o7("\x1B[0;34m"),a0=o7("\x1B[0;36m"),W8=o7("\x1B[1m"),Q9=o7("\x1B[2m"),v=o7("\x1B[0m")});import{existsSync as _f}from"fs";async function E7(){if(x4!==void 0)return x4;let Z="/opt/homebrew/bin/python3.12";if(_f(Z))return x4=Z,Z;let X=await X9("python3.12");if(X)return x4=X,X;let Q=await X9("python3");return x4=Q,Q}async function Y7(Z,X={}){let Q=await E7();if(!Q)return{stdout:"",stderr:"python3 not found",exitCode:127};return E0([Q,"-c",Z],X)}var x4;var r7=p(()=>{x9()});var ZL={};l0(ZL,{runStatus:()=>$h});import{existsSync as Y9,readFileSync as g3,readdirSync as iO,statSync as aO}from"fs";import{resolve as h8,basename as tf}from"path";import{homedir as ef}from"os";function sO(Z){let X=Math.trunc(Z);if(X>=1e6)return`${(Math.trunc(X/1e6*10)/10).toFixed(1)}M`;if(X>=1000)return`${(Math.trunc(X/1000*10)/10).toFixed(1)}K`;return String(X)}function nO(Z,X,Q){if(X===0)return null;let Y=Math.trunc(Z*100/X),J=Math.trunc(Z*LQ/X);if(J>LQ)J=LQ;let z=LQ-J,K=F8;if(Y>=80)K=L0;else if(Y>=50)K=p0;let $="=".repeat(Math.max(0,J))+" ".repeat(Math.max(0,z)),W=sO(Z),V=sO(X);return`  ${W8}${Q}${v} ${K}[${$}]${v} ${Y}% (${W} / ${V})`}async function Xh(){if(await X9("jq"))return!0;return process.stdout.write(`${L0}Error: jq is required but not installed.${v}
 `),process.stdout.write(`Install with:
 `),process.stdout.write(`  brew install jq    (macOS)
 `),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
@@ -1232,4 +1232,4 @@ Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
 `),2}case"start":{let{runStart:Y}=await Promise.resolve().then(() => (v_(),h_));return Y(Q)}default:return process.stderr.write(`Unknown command: ${X}
 `),process.stderr.write(g_),2}}cO();process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var pW0=await uW0(Bun.argv.slice(2));process.exit(pW0);
 
-//# debugId=C7A17AA3F6A8ADEB64756E2164756E21
+//# debugId=71D1F11FDC1381C964756E2164756E21

package/mcp/__init__.py

@@ -75,4 +75,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '9.12.4'
+__version__ = '9.12.6'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "9.12.4",
+  "version": "9.12.6",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 8 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/plugins/loki-mode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "loki-mode",
   "displayName": "Loki Mode",
-  "version": "9.12.4",
+  "version": "9.12.6",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",

package/tools/loop-harness-report.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""loop-harness-v1: what the verifiers in a run actually recorded.
+
+READ-ONLY. Opens .loki/events.jsonl and nothing else. Writes nothing, spawns
+nothing, and touches no runtime path. Rollback is deleting this file.
+
+WHY THIS REPORTS MOSTLY UNKNOWN, AND WHY THAT IS THE POINT. A loop-harness
+manifest wants, per verifier invocation: eligibility, the deterministic
+criterion, retry and timeout caps, latency, tokens, cash cost, the verdict,
+whether it changed the terminal outcome, false-positive review, and a rollback
+switch.
+
+Measured at v9.12.5, the runtime emits almost none of that:
+
+    code_review_complete        review_id, source, iteration
+    review_verification_failed  reason, iteration, implementation_retry
+    _evidence_gate_and_surface  nothing structured
+    _invariant_gate_and_surface nothing structured
+    _semantic_gate_and_surface  nothing structured
+
+So this reader CANNOT derive most columns. It reports them UNKNOWN rather than
+defaulting them, because a manifest that fills a cost column with 0.0 or an
+eligibility column with "yes" is asserting a measurement nobody took -- and a
+fabricated manifest about verification is worse than no manifest at all.
+
+The UNKNOWNs are the deliverable. They say exactly which instrumentation is
+missing, so a later decision to add it is evidenced rather than assumed.
+
+Exit codes follow this repo's convention:
+    0  verifier records were found and reported
+    2  the trace could not be read
+    3  nothing to check -- no verifier events in this workspace
+   64  usage error
+"""
+
+import argparse
+import json
+import os
+import sys
+
+sys.dont_write_bytecode = True
+
+UNKNOWN = "UNKNOWN"
+
+# Event types that represent a verifier doing something. Derived from
+# autonomy/run.sh's emit_event_json call sites, not invented here.
+_VERIFIER_EVENTS = {
+    "code_review_start",
+    "code_review_complete",
+    "code_review_council_complete",
+    "review_verification_failed",
+    "managed_review_council_ok",
+    "gate_stuck",
+    "policy_denied",
+    "task_completion_claim",
+}
+
+# Fields a loop-harness manifest wants, and where each one comes from today.
+# "" means no emitter records it, so the column reads UNKNOWN for every row.
+_FIELD_SOURCES = {
+    "verifier": "event type",
+    "iteration": "iteration",
+    "verdict": "partial: only the failure path records a reason",
+    "eligible": "",
+    "criterion": "",
+    "retry_cap": "",
+    "timeout_cap": "",
+    "latency_ms": "",
+    "tokens": "",
+    "cost_usd": "",
+    "changed_terminal_outcome": "",
+    "false_positive_reviewed": "",
+    "rollback_switch": "",
+}
+
+
+class _Parser(argparse.ArgumentParser):
+    """Usage errors exit 64, not argparse's default 2.
+
+    In this repo 2 means "could NOT be checked" -- a real answer about the
+    subject. A mistyped flag is not that.
+    """
+
+    def error(self, message):
+        self.print_usage(sys.stderr)
+        sys.stderr.write("%s: error: %s\n" % (self.prog, message))
+        raise SystemExit(64)
+
+
+def _events(path):
+    """Every well-formed record, oldest first. A torn line is skipped.
+
+    events.jsonl is appended to by concurrent shell writers, so a partial
+    final line is normal operation and must not blank out the history behind
+    it.
+    """
+    out = []
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    rec = json.loads(line)
+                except (ValueError, json.JSONDecodeError):
+                    continue
+                if isinstance(rec, dict):
+                    out.append(rec)
+    except OSError:
+        return None
+    return out
+
+
+def _row(rec):
+    """One verifier invocation, with every underivable field UNKNOWN."""
+    data = rec.get("data") if isinstance(rec.get("data"), dict) else {}
+    etype = rec.get("type") or UNKNOWN
+
+    verdict = UNKNOWN
+    if etype in ("code_review_complete", "managed_review_council_ok"):
+        # Completion is not a verdict: these fire when the council FINISHED,
+        # not when it approved. Recording "pass" here would invent an outcome.
+        verdict = UNKNOWN
+    elif etype == "review_verification_failed":
+        verdict = data.get("reason") or "failed"
+    elif etype == "policy_denied":
+        verdict = "denied"
+
+    row = {
+        "verifier": etype,
+        "timestamp": rec.get("timestamp") or UNKNOWN,
+        "iteration": data.get("iteration", UNKNOWN),
+        "verdict": verdict,
+    }
+    for field, source in _FIELD_SOURCES.items():
+        if field in row:
+            continue
+        row[field] = UNKNOWN if not source else data.get(field, UNKNOWN)
+    return row
+
+
+def report(loki_dir):
+    """The manifest envelope. Empty results always carry a reason."""
+    path = os.path.join(loki_dir, "events.jsonl")
+    env = {
+        "report": "loop-harness-v1",
+        "source": [path],
+        "rows": [],
+        "count": 0,
+        "unmeasured_fields": sorted(f for f, s in _FIELD_SOURCES.items()
+                                    if not s),
+        "reason": None,
+    }
+    if not os.path.isdir(loki_dir):
+        env["reason"] = "no .loki directory at %s" % loki_dir
+        return env, 3
+    if not os.path.isfile(path):
+        env["reason"] = ("%s does not exist, so no verifier ever recorded "
+                         "anything here" % path)
+        return env, 3
+
+    records = _events(path)
+    if records is None:
+        env["reason"] = "%s could not be read" % path
+        return env, 2
+
+    rows = [_row(r) for r in records if r.get("type") in _VERIFIER_EVENTS]
+    if not rows:
+        # NOT an empty table. "no verifier events" and "the verifiers all
+        # passed" are different claims, and only one of them is supported.
+        env["reason"] = (
+            "no verifier events among %d records in this trace (the run "
+            "predates verifier tracing, or no verifier ran)" % len(records))
+        return env, 3
+
+    env["rows"] = rows
+    env["count"] = len(rows)
+    return env, 0
+
+
+def main(argv=None):
+    parser = _Parser(description="loop-harness-v1 verifier manifest (read-only)")
+    parser.add_argument("--loki-dir", default=os.environ.get("LOKI_DIR")
+                        or os.path.join(os.getcwd(), ".loki"))
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+
+    env, code = report(args.loki_dir)
+
+    if args.json:
+        print(json.dumps(env, indent=2))
+        return code
+
+    print("loop-harness-v1  source: %s" % ", ".join(env["source"]))
+    if not env["rows"]:
+        print("  nothing to check: %s" % env["reason"])
+    else:
+        print("  %-30s %-10s %s" % ("VERIFIER", "ITERATION", "VERDICT"))
+        for r in env["rows"]:
+            print("  %-30s %-10s %s"
+                  % (r["verifier"], r["iteration"], r["verdict"]))
+        print("  %d verifier records" % env["count"])
+    print("")
+    print("  NOT RECORDED BY THE RUNTIME (every row reads UNKNOWN):")
+    for f in env["unmeasured_fields"]:
+        print("    - %s" % f)
+    print("  These are the fields a loop-harness manifest needs and the")
+    print("  runtime does not emit. They are reported UNKNOWN rather than")
+    print("  defaulted, because a fabricated verification manifest is worse")
+    print("  than an absent one.")
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())