loki-mode 8.96.0 → 8.98.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 8 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v8.96.0
+# Loki Mode v8.98.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -469,4 +469,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v8.96.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v8.98.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-8.96.0
+8.98.0

package/dashboard/__init__.py

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

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var m_=Object.create;var{getPrototypeOf:u_,defineProperty:eK,getOwnPropertyNames:p_}=Object;var d_=Object.prototype.hasOwnProperty;function c_(Z){return this[Z]}var l_,i_,a_=(Z,X,Q)=>{var Y=Z!=null&&typeof Z==="object";if(Y){var J=X?l_??=new WeakMap:i_??=new WeakMap,z=J.get(Z);if(z)return z}Q=Z!=null?m_(u_(Z)):{};let K=X||!Z||!Z.__esModule?eK(Q,"default",{value:Z,enumerable:!0}):Q;for(let $ of p_(Z))if(!d_.call(K,$))eK(K,$,{get:c_.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 s_=(Z)=>Z;function n_(Z,X){this[Z]=s_.bind(null,X)}var l0=(Z,X)=>{for(var Q in X)eK(Z,Q,{get:X[Q],enumerable:!0,configurable:!0,set:n_.bind(X,Q)})};var p=(Z,X)=>()=>(Z&&(X=Z(Z=0)),X);var e0=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 o_}from"url";import{existsSync as UQ}from"fs";import{homedir as r_}from"os";function t_(){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(r_(),".loki")}var RO,i0;var H8=p(()=>{RO=Z$(o_(import.meta.url));i0=t_()});import{readFileSync as e_}from"fs";import{resolve as Zf,dirname as Xf}from"path";import{fileURLToPath as Qf}from"url";function h3(){if(h5!==null)return h5;let Z="8.96.0";if(typeof Z==="string"&&Z.length>0)return h5=Z,h5;try{let X=Xf(Qf(import.meta.url)),Q=X$(X);h5=e_(Zf(Q,"VERSION"),"utf-8").trim()}catch{h5="unknown"}return h5}var h5=null;var BQ=p(()=>{H8()});var bO={};l0(bO,{runOrThrow:()=>jf,run:()=>E0,readStreamCapped:()=>NQ,commandVersion:()=>Tf,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 jf(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=Mf(Z),Q=await E0(["sh","-c",`command -v ${X}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function Mf(Z){if(!/^[A-Za-z0-9._/-]+$/.test(Z))throw Error(`refused to shell-escape suspect token: ${Z}`);return Z}async function Tf(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 wf?"":Z}var wf,L0,F8,p0,zV0,a0,W8,Q9,v;var S6=p(()=>{wf=(process.env.NO_COLOR??"").length>0;L0=o7("\x1B[0;31m"),F8=o7("\x1B[0;32m"),p0=o7("\x1B[1;33m"),zV0=o7("\x1B[0;34m"),a0=o7("\x1B[0;36m"),W8=o7("\x1B[1m"),Q9=o7("\x1B[2m"),v=o7("\x1B[0m")});import{existsSync as bf}from"fs";async function E7(){if(x4!==void 0)return x4;let Z="/opt/homebrew/bin/python3.12";if(bf(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:()=>Kh});import{existsSync as Y9,readFileSync as g3,readdirSync as iO,statSync as aO}from"fs";import{resolve as h8,basename as rf}from"path";import{homedir as tf}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 Zh(){if(await X9("jq"))return!0;return process.stdout.write(`${L0}Error: jq is required but not installed.${v}
+var m_=Object.create;var{getPrototypeOf:u_,defineProperty:eK,getOwnPropertyNames:p_}=Object;var d_=Object.prototype.hasOwnProperty;function c_(Z){return this[Z]}var l_,i_,a_=(Z,X,Q)=>{var Y=Z!=null&&typeof Z==="object";if(Y){var J=X?l_??=new WeakMap:i_??=new WeakMap,z=J.get(Z);if(z)return z}Q=Z!=null?m_(u_(Z)):{};let K=X||!Z||!Z.__esModule?eK(Q,"default",{value:Z,enumerable:!0}):Q;for(let $ of p_(Z))if(!d_.call(K,$))eK(K,$,{get:c_.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 s_=(Z)=>Z;function n_(Z,X){this[Z]=s_.bind(null,X)}var l0=(Z,X)=>{for(var Q in X)eK(Z,Q,{get:X[Q],enumerable:!0,configurable:!0,set:n_.bind(X,Q)})};var p=(Z,X)=>()=>(Z&&(X=Z(Z=0)),X);var e0=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 o_}from"url";import{existsSync as UQ}from"fs";import{homedir as r_}from"os";function t_(){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(r_(),".loki")}var RO,i0;var H8=p(()=>{RO=Z$(o_(import.meta.url));i0=t_()});import{readFileSync as e_}from"fs";import{resolve as Zf,dirname as Xf}from"path";import{fileURLToPath as Qf}from"url";function h3(){if(h5!==null)return h5;let Z="8.98.0";if(typeof Z==="string"&&Z.length>0)return h5=Z,h5;try{let X=Xf(Qf(import.meta.url)),Q=X$(X);h5=e_(Zf(Q,"VERSION"),"utf-8").trim()}catch{h5="unknown"}return h5}var h5=null;var BQ=p(()=>{H8()});var bO={};l0(bO,{runOrThrow:()=>jf,run:()=>E0,readStreamCapped:()=>NQ,commandVersion:()=>Tf,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 jf(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=Mf(Z),Q=await E0(["sh","-c",`command -v ${X}`],{timeoutMs:5000});if(Q.exitCode===0)return Q.stdout.trim()||null;return null}function Mf(Z){if(!/^[A-Za-z0-9._/-]+$/.test(Z))throw Error(`refused to shell-escape suspect token: ${Z}`);return Z}async function Tf(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 wf?"":Z}var wf,L0,F8,p0,zV0,a0,W8,Q9,v;var S6=p(()=>{wf=(process.env.NO_COLOR??"").length>0;L0=o7("\x1B[0;31m"),F8=o7("\x1B[0;32m"),p0=o7("\x1B[1;33m"),zV0=o7("\x1B[0;34m"),a0=o7("\x1B[0;36m"),W8=o7("\x1B[1m"),Q9=o7("\x1B[2m"),v=o7("\x1B[0m")});import{existsSync as bf}from"fs";async function E7(){if(x4!==void 0)return x4;let Z="/opt/homebrew/bin/python3.12";if(bf(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:()=>Kh});import{existsSync as Y9,readFileSync as g3,readdirSync as iO,statSync as aO}from"fs";import{resolve as h8,basename as rf}from"path";import{homedir as tf}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 Zh(){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(() => (h_(),f_));return Y(Q)}default:return process.stderr.write(`Unknown command: ${X}
 `),process.stderr.write(v_),2}}cO();process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var uW0=await mW0(Bun.argv.slice(2));process.exit(uW0);
 
-//# debugId=3B5AE9CBA3FA521064756E2164756E21
+//# debugId=A8CE268C65C8280964756E2164756E21

package/mcp/__init__.py

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "8.96.0",
+  "version": "8.98.0",
   "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": "8.96.0",
+  "version": "8.98.0",
   "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/gate-report.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""Render a ci-gate verdict as CI-native output. Never invent a verdict.
+
+WHY THIS EXISTS. tools/ci-gate.py already decides correctly and exits 0/1/2.
+But in a CI run its text table lands in a collapsed log that nobody opens. The
+two surfaces an engineer actually reads are the run page ($GITHUB_STEP_SUMMARY,
+markdown) and the PR diff annotations (::error / ::warning workflow commands).
+Nothing carried our verdict to either, so the gate's most important state --
+"this policy could not be checked" -- was invisible at exactly the moment it
+mattered.
+
+    python3 tools/ci-gate.py <ws> --max-usd 5 --json \
+        | python3 tools/gate-report.py --format markdown >> "$GITHUB_STEP_SUMMARY"
+
+THE RULE THIS FILE EXISTS TO HOLD, inherited from ci-gate.py:
+
+    A POLICY THAT COULD NOT BE EVALUATED HAS NOT PASSED.
+
+A renderer is where that rule dies quietly. A table styles UNEVALUABLE like a
+minor note; an annotation layer emits ::error for failures and simply skips
+everything else. Both produce a run page with no red on it, and a reviewer
+reads absence-of-red as pass. So UNEVALUABLE renders exactly as prominently as
+FAIL, and in the github format it is a ::warning at minimum -- never silent,
+never ::notice. There is one severity map, below, and both formats read it.
+
+WHY THE EXIT CODE IS RE-EMITTED. In `ci-gate.py ... | gate-report.py` the shell
+keeps ONLY the last command's status. ci-gate's 2 is discarded by the pipe. If
+this file exited 0 for a rendered blind gate, adding a human-readable report
+would have converted a blocked merge into a green check -- the pipeline would
+be made LESS safe by the act of describing itself. So the input's own exit_code
+is re-emitted, and anything that is not a recognised verdict exits 2.
+
+WHAT IT REFUSES TO DO. It never computes a state, only relays one. A row with
+no state, or a state word this file does not recognise, is UNEVALUABLE -- the
+input did not carry a verdict, and a renderer that fills that gap with "pass"
+is manufacturing evidence. Empty stdin and malformed JSON are errors on stderr
+with exit 2, never an empty report: a report of nothing is indistinguishable
+from a clean run.
+
+Exit: mirrors the input verdict (0 pass, 1 failed, 2 unevaluable); 2 on any
+input this file could not parse.
+"""
+
+import argparse
+import json
+import sys
+
+PASS, FAIL, UNEVALUABLE = 0, 1, 2
+
+# THE ONE MAPPING. Both formats read it, so a change of severity cannot apply
+# to one surface and not the other. "notice" is reserved for PASS: an
+# unevaluable policy demoted to a notice is precisely the silent-green failure
+# this tool exists to prevent.
+_SEVERITY = {"PASS": "notice", "FAIL": "error", "UNEVALUABLE": "warning"}
+
+_EXIT = {"PASS": PASS, "FAIL": FAIL, "UNEVALUABLE": UNEVALUABLE}
+
+# ponytail: markdown emphasis is derived, not a second table to drift.
+_UNKNOWN = ("UNEVALUABLE", "state not reported by the gate: the input carried "
+            "no recognised verdict for this policy, so it has not passed")
+
+
+def _state_of(row):
+    """The row's own verdict, or UNEVALUABLE. Never a default of PASS."""
+    if not isinstance(row, dict):
+        return _UNKNOWN[0], "malformed policy entry: %r" % (row,), "?"
+    state = row.get("state")
+    policy = str(row.get("policy") or "?")
+    reason = row.get("reason")
+    reason = reason.strip() if isinstance(reason, str) and reason.strip() \
+        else "no detail reported"
+    if not isinstance(state, str) or state.upper() not in _SEVERITY:
+        return _UNKNOWN[0], "%s (was %r)" % (_UNKNOWN[1], state), policy
+    return state.upper(), reason, policy
+
+
+def _rows(verdict):
+    """Every policy row, plus a synthetic row when the gate carried none.
+
+    An empty policies list with a top-level UNEVALUABLE is ci-gate's
+    "no policy configured" verdict. Rendering an empty table there would draw a
+    header and no rows, which reads as a clean run -- the exact inversion this
+    file exists to stop.
+    """
+    policies = verdict.get("policies")
+    out = []
+    if isinstance(policies, list):
+        for row in policies:
+            out.append(_state_of(row))
+    if out:
+        return out
+    # No policy results arrived. Whatever the header claims, nothing was
+    # checked, so this row is UNEVALUABLE unconditionally -- trusting a
+    # top-level "PASS" here would render a green table built from zero
+    # evidence, which is the one thing this file must never do.
+    return [(_UNKNOWN[0], _overall_reason(verdict), "(none)")]
+
+
+def _overall_reason(verdict):
+    reason = verdict.get("reason")
+    if isinstance(reason, str) and reason.strip():
+        return reason.strip()
+    return "the gate reported no policy results and no reason"
+
+
+def _verdict_state(verdict):
+    """The overall state, never weaker than the worst row.
+
+    The header is a claim; the rows are the evidence. A body asserting PASS
+    over a FAILED or unreported row is not a pass, so the summary line is
+    reconciled against the rows here -- the same weakest-link rule ci-gate
+    applies, and the same one exit_code() applies. Reporting a green summary
+    above a red table is how a reader ends up trusting the wrong one.
+    """
+    state = verdict.get("state")
+    claimed = state.upper() if isinstance(state, str) \
+        and state.upper() in _SEVERITY else _UNKNOWN[0]
+    worst = max([_EXIT[claimed]] +
+                [_EXIT[row[0]] for row in _rows(verdict)])
+    return {v: k for k, v in _EXIT.items()}[worst]
+
+
+def render_markdown(verdict):
+    state = _verdict_state(verdict)
+    lines = ["## Merge gate: %s" % _headline(state), "",
+             "| Policy | State | Detail |", "| --- | --- | --- |"]
+    for row_state, reason, policy in _rows(verdict):
+        # Bold every non-pass. An unevaluable row must not be visually quieter
+        # than a failed one on the run page.
+        cell = row_state if row_state == "PASS" else "**%s**" % row_state
+        lines.append("| %s | %s | %s |" % (policy, cell, _cell(reason)))
+    lines.append("")
+    lines.append("%s -- %s" % (_headline(state), _overall_reason(verdict)))
+    return "\n".join(lines)
+
+
+def _headline(state):
+    if state == "PASS":
+        return "PASS"
+    if state == "FAIL":
+        return "FAIL"
+    return "UNEVALUABLE (could not be checked -- this is not a pass)"
+
+
+def _cell(text):
+    # A pipe in a reason would silently split the row into extra columns.
+    return " ".join(text.split()).replace("|", "\\|")
+
+
+def render_github(verdict, file_hint=None):
+    """Workflow commands. Non-pass rows are never silent."""
+    lines = []
+    loc = "file=%s," % file_hint if file_hint else ""
+    for row_state, reason, policy in _rows(verdict):
+        lines.append("::%s %stitle=gate: %s (%s)::%s"
+                     % (_SEVERITY[row_state], loc, policy, row_state,
+                        _annotation_text(reason)))
+    state = _verdict_state(verdict)
+    lines.append("::%s %stitle=merge gate %s::%s"
+                 % (_SEVERITY[state], loc, state,
+                    _annotation_text(_overall_reason(verdict))))
+    return "\n".join(lines)
+
+
+def _one_line(text):
+    # A raw newline would terminate the workflow command mid-message and leave
+    # the tail rendered as plain log noise.
+    return " ".join(text.split())
+
+
+def _annotation_text(text):
+    # % opens an escape sequence in a workflow-command message, and
+    # cost-guard's --max-increase-pct reasons carry literal percentages. Only
+    # the github format needs this; plain text must keep its real % sign.
+    return _one_line(text).replace("%", "%25")
+
+
+def render_text(verdict):
+    lines = ["%-10s %-12s %s" % ("POLICY", "STATE", "DETAIL")]
+    for row_state, reason, policy in _rows(verdict):
+        lines.append("%-10s %-12s %s" % (policy, row_state, _one_line(reason)))
+    lines.append("")
+    lines.append("GATE: %s -- %s" % (_headline(_verdict_state(verdict)),
+                                     _overall_reason(verdict)))
+    return "\n".join(lines)
+
+
+_FORMATS = {"markdown": render_markdown, "github": render_github,
+            "text": render_text}
+
+
+def exit_code(verdict):
+    """The input's own exit semantics. A pipe drops them; this restores them."""
+    code = verdict.get("exit_code")
+    if isinstance(code, bool) or not isinstance(code, int) \
+            or code not in (PASS, FAIL, UNEVALUABLE):
+        # No trustworthy verdict came in, so none goes out. 2 matches
+        # ci-gate's own vocabulary: to a CI job, "blind" and "broken" are the
+        # same fact and neither may merge.
+        return UNEVALUABLE
+    # Cross-check: a body claiming PASS while carrying a non-pass row is not a
+    # pass. Weakest link, same rule ci-gate uses, applied to what arrived --
+    # and the same reconciliation the rendered summary shows, so the exit code
+    # can never disagree with the report a human just read.
+    return max(code, _EXIT[_verdict_state(verdict)])
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        description="Render a ci-gate JSON verdict as CI-native output.")
+    ap.add_argument("--format", choices=sorted(_FORMATS), default="markdown",
+                    help="markdown (step summary), github (annotations), text")
+    ap.add_argument("--file", dest="file_hint",
+                    help="path to attach to github annotations; omitted when "
+                         "not given, because an annotation on the wrong file "
+                         "is worse than none")
+    args = ap.parse_args(argv)
+
+    raw = sys.stdin.read()
+    if not raw.strip():
+        # A report of nothing looks exactly like a clean run.
+        sys.stderr.write("gate-report: empty stdin -- expected ci-gate JSON on "
+                         "stdin. Nothing to report is not a pass.\n")
+        return UNEVALUABLE
+    try:
+        verdict = json.loads(raw)
+    except ValueError as exc:
+        sys.stderr.write("gate-report: could not parse the gate verdict: %s\n"
+                         % exc)
+        return UNEVALUABLE
+    if not isinstance(verdict, dict):
+        sys.stderr.write("gate-report: expected a JSON object from ci-gate, "
+                         "got %s\n" % type(verdict).__name__)
+        return UNEVALUABLE
+
+    # Render fully before printing: a malformed body must never emit a partial
+    # report that a reader mistakes for the whole verdict.
+    if args.format == "github":
+        out = render_github(verdict, args.file_hint)
+    else:
+        out = _FORMATS[args.format](verdict)
+    code = exit_code(verdict)
+    print(out)
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/policy-load.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""Merge policy as a version-controlled FILE, not a CI flag nobody reviews.
+
+WHY THIS EXISTS. tools/ci-gate.py takes its policy as CLI flags: --max-usd,
+--require-receipt. That works exactly once, in one job, on one machine. The
+ceiling lives in YAML nobody diffs, it cannot be reviewed in a PR, and two
+repos in the same org drift apart with nobody able to name the moment it
+happened. Lowering a ceiling should look like a code change, because it is one.
+
+So: put the policy in a file, load it here, and hand ci-gate its flags.
+
+    python3 tools/ci-gate.py $(python3 tools/policy-load.py --as-args)
+
+THAT COMPOSITION IS WHY EVERY FAILURE HERE IS LOUD. This tool's stdout becomes
+another gate's argv. A loader that shrugs at bad input does not produce a weak
+policy, it produces a gate invoked with NOTHING TO ENFORCE, which ci-gate's own
+docstring calls a vacuously-green gate: worse than no gate, because it is
+trusted. This repo has paid for that shape four times (four detectors missing
+from the package, a deferred dist check, a tarball assertion passing on "6 or
+more" of 6). Every one was a check reporting a pass without having checked.
+
+Hence four rules, each of which is one way to be silently unenforced:
+
+  UNKNOWN KEY IS AN ERROR. "max_usd_" is not "max_usd". Skipping it leaves an
+  operator certain a ceiling is enforced while nothing is. The misspelling is
+  invisible precisely because the file still looks like a policy. Named, not
+  counted: "1 unknown key" does not tell you which line to fix.
+
+  EMPTY OR ABSENT IS AN ERROR, not an empty policy. An empty policy enforces
+  nothing while looking configured. And "implies no flags" is the same hole one
+  level up: {"require_receipt": false} is valid JSON, has a key, and expands to
+  an empty argv. So the test is what the policy ENFORCES, not what it contains.
+
+  VALUES ARE VALIDATED, NOT JUST KEYS. A ceiling of -1 passes every run. So
+  does NaN, which json.loads accepts as a bare literal and which loses every
+  comparison it appears in -- an unenforceable ceiling that reads as a number.
+  So does True, which is an int in Python and floats to 1.0.
+
+  MALFORMED JSON REPORTS THE PARSE ERROR AND THE PATH, never a partial policy.
+
+Exit 0 only when a non-empty, fully-valid policy loaded and implies at least
+one flag. Diagnostics go to stderr, always: anything on stdout gets word-split
+straight into ci-gate's argv.
+
+Usage:
+  tools/policy-load.py [--file .loki-policy.json] [--json] [--as-args]
+"""
+
+import argparse
+import json
+import math
+import sys
+
+DEFAULT_FILE = ".loki-policy.json"
+
+# The entire schema. Two keys, because ci-gate enforces exactly two policies.
+# `workspace` is per-invocation and not a policy (and a path with a space would
+# silently split under $(...)); `json` is an output format. Neither belongs here.
+KNOWN_KEYS = ("max_usd", "require_receipt")
+
+
+class PolicyError(Exception):
+    """A policy that must not be handed to a gate."""
+
+
+def _check_max_usd(value):
+    # bool is a subclass of int: `true` would otherwise become a $1.00 ceiling.
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return "max_usd must be a number, got {!r}".format(value)
+    # NaN and Infinity are bare literals json.loads accepts. NaN loses every
+    # comparison, so a NaN ceiling never trips while looking like a number.
+    # isfinite raises OverflowError on a 400-digit int literal; that already
+    # fails closed, but a traceback is a worse message than a named reason.
+    try:
+        finite = math.isfinite(value)
+    except OverflowError:
+        finite = False
+    if not finite:
+        return "max_usd must be a finite number, got {!r}".format(value)
+    if value < 0:
+        return "max_usd must not be negative, got {!r}".format(value)
+    return None
+
+
+def _check_require_receipt(value):
+    # "true" is a string and is truthy; it is not a boolean policy.
+    if not isinstance(value, bool):
+        return "require_receipt must be true or false, got {!r}".format(value)
+    return None
+
+
+VALIDATORS = {
+    "max_usd": _check_max_usd,
+    "require_receipt": _check_require_receipt,
+}
+
+
+def load(path):
+    """Return a validated policy dict, or raise PolicyError naming the problem."""
+    try:
+        with open(path, encoding="utf-8") as handle:
+            raw = handle.read()
+    except FileNotFoundError:
+        raise PolicyError(
+            "no policy file at {}: a gate with no policy enforces nothing".format(path))
+    except OSError as exc:
+        raise PolicyError("cannot read {}: {}".format(path, exc))
+
+    if not raw.strip():
+        raise PolicyError(
+            "policy file is empty: {} -- an empty policy enforces nothing "
+            "while looking configured".format(path))
+
+    try:
+        policy = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise PolicyError("malformed JSON in {}: {}".format(path, exc))
+
+    if not isinstance(policy, dict):
+        raise PolicyError(
+            "policy in {} must be a JSON object, got {}".format(
+                path, type(policy).__name__))
+
+    # Named, sorted, and ALL of them: fixing one misspelling at a time across
+    # three re-runs is how the third one gets abandoned.
+    unknown = sorted(k for k in policy if k not in KNOWN_KEYS)
+    if unknown:
+        raise PolicyError(
+            "unknown policy key(s) in {}: {} -- known keys are: {}".format(
+                path, ", ".join(unknown), ", ".join(KNOWN_KEYS)))
+
+    # Iterate KNOWN_KEYS, not policy.items(): indexing VALIDATORS by a key
+    # straight from the file makes an unknown key a KeyError traceback instead
+    # of the named message above. That still exits non-zero, so the check looks
+    # tested while the operator gets a stack trace naming only the first typo.
+    problems = [msg for key in KNOWN_KEYS if key in policy
+                for msg in [VALIDATORS[key](policy[key])] if msg]
+    if problems:
+        raise PolicyError("invalid policy in {}: {}".format(path, "; ".join(problems)))
+
+    if not policy:
+        raise PolicyError(
+            "policy in {} is empty: a gate driven by an empty policy enforces "
+            "nothing while looking configured".format(path))
+
+    return policy
+
+
+def as_args(policy):
+    """The ci-gate flags this policy implies."""
+    args = []
+    if "max_usd" in policy:
+        args += ["--max-usd", repr(float(policy["max_usd"]))]
+    if policy.get("require_receipt"):
+        args.append("--require-receipt")
+    return args
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        description="Load and validate a merge policy file for ci-gate.py.")
+    ap.add_argument("--file", default=DEFAULT_FILE,
+                    help="policy file to load; default {}".format(DEFAULT_FILE))
+    ap.add_argument("--json", action="store_true", dest="as_json",
+                    help="emit the validated policy as JSON")
+    ap.add_argument("--as-args", action="store_true", dest="args_only",
+                    help="emit the ci-gate flags this policy implies")
+    args = ap.parse_args(argv)
+
+    try:
+        policy = load(args.file)
+        flags = as_args(policy)
+        # require_receipt:false is valid, non-empty, and enforces NOTHING. Let
+        # it exit 0 and `ci-gate $(...)` runs with an empty argv -- the same
+        # vacuously-green gate this file exists to prevent, one level up.
+        if not flags:
+            raise PolicyError(
+                "policy in {} enforces nothing: it implies no ci-gate flags, so "
+                "the gate would run with nothing to check".format(args.file))
+    except PolicyError as exc:
+        print("policy-load: {}".format(exc), file=sys.stderr)
+        return 1
+
+    if args.args_only:
+        print(" ".join(flags))
+    elif args.as_json:
+        print(json.dumps(policy, indent=2, sort_keys=True))
+    else:
+        for key in sorted(policy):
+            print("{} = {}".format(key, json.dumps(policy[key])))
+        print("ci-gate args: {}".format(" ".join(flags)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/signing-status.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""Can this machine produce SIGNED receipts? Prove it, do not assume it.
+
+WHY THIS EXISTS. An unsigned Evidence Receipt proves INTEGRITY but not ORIGIN.
+The hash says the bytes were not tampered with; it says nothing about who
+produced them, and anyone can generate a receipt with a valid hash. Origin is
+the part a third party is actually buying. GPG signing closes that gap and has
+shipped since the proof generator learned LOKI_PROOF_GPG_KEY -- default OFF,
+undiscoverable, and silent when broken.
+
+Silent is the dangerous word. autonomy/lib/proof-generator.py:_gpg_detached_sign
+swallows EVERY failure and returns None: missing key, expired key, revoked key,
+a passphrase this environment cannot supply. Signing is best-effort by design so
+a gpg problem never blocks proof emission. The cost of that design is that a
+user who set LOKI_PROOF_GPG_KEY, believes receipts are signed, and has a broken
+key gets UNSIGNED receipts forever with no error anywhere. This tool is the only
+place that failure becomes visible.
+
+So the bar here is higher than "gpg is installed and a key id is set". That
+sentence is compatible with every one of the failures above. The only honest
+evidence that this machine can sign is a real detached-sign of a real payload
+followed by a real verify of the resulting signature -- with the SAME argv the
+receipt pipeline uses, or the round trip predicts nothing about the pipeline.
+
+FOUR STATES, NEVER A BOOLEAN. Collapsing these sends a user to debug the wrong
+thing, which for a security control is worse than saying nothing:
+
+    ok              round trip signed AND verified. Receipts carry origin.
+    broken          configured, and signing FAILED. Receipts silently unsigned.
+    not_configured  gpg works, LOKI_PROOF_GPG_KEY unset. Nothing is wrong.
+    gpg_absent      no gpg on PATH. Signing is impossible until installed.
+
+KEY MATERIAL NEVER LEAVES. A key ID is an identifier and is safe to print.
+Secret key bytes and passphrases are not, and gpg writes diagnostics to stderr
+that can quote them. Raw gpg stderr is therefore NEVER printed: it is
+classified into a known reason and only the classification is emitted. No
+--export path is invoked anywhere in this file. Requirement and implementation
+are the same line: print the reason, not the transcript.
+
+Read-only against the keyring: no key is created, deleted, imported, or
+modified. The round trip signs a scratch file in a temp dir that is removed
+afterwards, and uses the caller's real GNUPGHOME because the question being
+answered is whether the REAL keyring can sign.
+"""
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+# The payload is arbitrary: the round trip proves the KEY works, not that any
+# particular bytes are special. Fixed and tiny so a signature is fast.
+_SCRATCH_PAYLOAD = b"loki-signing-status round-trip probe\n"
+
+_TIMEOUT = 30
+
+# Ordered: the first match wins, so the more specific pattern precedes the
+# general one. Left side is matched against LOWERCASED gpg stderr; right side is
+# what the user is told. Never the raw stderr -- see the module docstring.
+_REASONS = (
+    ("no secret key", "no secret key for that key id in this keyring"),
+    ("secret key not available", "no secret key for that key id in this keyring"),
+    ("no default secret key", "no secret key for that key id in this keyring"),
+    ("unusable secret key", "the secret key is unusable (expired or revoked)"),
+    ("key has expired", "the key has expired"),
+    ("expired", "the key has expired"),
+    ("has been revoked", "the key has been revoked"),
+    ("revoked", "the key has been revoked"),
+    ("bad passphrase", "the passphrase was rejected"),
+    ("passphrase", "the key needs a passphrase this environment cannot supply"),
+    ("pinentry", "the key needs a passphrase this environment cannot supply"),
+    ("inappropriate ioctl", "the key needs a passphrase this environment cannot supply"),
+    ("no such file", "the key id does not resolve to a key in this keyring"),
+    ("not found", "the key id does not resolve to a key in this keyring"),
+)
+
+
+def _classify(stderr, fallback):
+    """Map gpg stderr onto a known reason. NEVER returns the stderr itself.
+
+    Anything unrecognized degrades to a generic fallback rather than leaking the
+    transcript, because the unrecognized case is exactly the one whose contents
+    cannot be predicted -- and therefore the one most likely to quote key
+    material or a passphrase prompt.
+    """
+    low = (stderr or "").lower()
+    for needle, reason in _REASONS:
+        if needle in low:
+            return reason
+    return fallback
+
+
+def _round_trip(key_id):
+    """Sign a scratch payload with key_id and verify the signature.
+
+    Returns (True, None) when the signature verified, else (False, reason).
+
+    The argv MUST mirror autonomy/lib/proof-generator.py:_gpg_detached_sign and
+    autonomy/lib/proof-verify.py:_verify_gpg. A round trip that signs some other
+    way can succeed while the receipt pipeline still emits unsigned, which would
+    make this tool confidently wrong in the one direction that matters.
+    """
+    tmp = tempfile.mkdtemp(prefix="loki-signing-status-")
+    try:
+        data_path = os.path.join(tmp, "payload.bin")
+        with open(data_path, "wb") as fh:
+            fh.write(_SCRATCH_PAYLOAD)
+
+        try:
+            signed = subprocess.run(
+                ["gpg", "--batch", "--yes", "--armor", "--detach-sign",
+                 "--local-user", key_id, "--output", "-"],
+                input=_SCRATCH_PAYLOAD, capture_output=True, timeout=_TIMEOUT,
+            )
+        except subprocess.TimeoutExpired:
+            # --batch should make gpg fail rather than prompt, but a wedged
+            # agent or a pinentry that ignores batch mode hangs instead. Never
+            # let this tool hang: a timeout IS a signing failure.
+            return False, "gpg timed out (a passphrase prompt is the usual cause)"
+        except OSError as exc:
+            return False, "gpg could not be executed (%s)" % type(exc).__name__
+
+        if signed.returncode != 0 or not signed.stdout:
+            stderr = signed.stderr.decode("utf-8", errors="replace")
+            return False, _classify(stderr, "gpg refused to sign with that key")
+
+        sig_path = os.path.join(tmp, "payload.sig")
+        with open(sig_path, "wb") as fh:
+            fh.write(signed.stdout)
+
+        try:
+            checked = subprocess.run(
+                ["gpg", "--verify", sig_path, data_path],
+                capture_output=True, timeout=_TIMEOUT,
+            )
+        except subprocess.TimeoutExpired:
+            return False, "gpg timed out verifying its own signature"
+        except OSError as exc:
+            return False, "gpg could not be executed (%s)" % type(exc).__name__
+
+        if checked.returncode != 0:
+            # gpg produced bytes that gpg itself will not accept. A naive
+            # "signing worked, we got output" check calls this state OK.
+            stderr = checked.stderr.decode("utf-8", errors="replace")
+            return False, _classify(
+                stderr, "gpg produced a signature it could not verify")
+
+        return True, None
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def evaluate(env=None):
+    """Resolve the signing state. Returns a JSON-safe dict.
+
+    Pure with respect to the keyring: reads it, changes nothing.
+    """
+    env = os.environ if env is None else env
+    gpg_path = shutil.which("gpg")
+    key_id = (env.get("LOKI_PROOF_GPG_KEY") or "").strip()
+
+    result = {
+        "gpg_installed": gpg_path is not None,
+        "gpg_path": gpg_path,
+        "key_id_set": bool(key_id),
+        # A key ID is an identifier, not key material: safe to echo back so the
+        # user can see WHICH key was tried.
+        "key_id": key_id or None,
+        "round_trip_verified": False,
+    }
+
+    if gpg_path is None:
+        result["status"] = "gpg_absent"
+        result["reason"] = "gpg is not on PATH"
+        result["next_command"] = "brew install gnupg   # or: apt-get install gnupg"
+        return result
+
+    if not key_id:
+        result["status"] = "not_configured"
+        result["reason"] = "LOKI_PROOF_GPG_KEY is not set"
+        result["next_command"] = (
+            "gpg --list-secret-keys --keyid-format=long   "
+            "# then: export LOKI_PROOF_GPG_KEY=<key-id>")
+        return result
+
+    verified, reason = _round_trip(key_id)
+    result["round_trip_verified"] = verified
+
+    # The single load-bearing line in this file. "ok" is reachable ONLY through
+    # a completed sign-and-verify round trip; every other path is a failure with
+    # a reason. Deriving status from gpg_installed and key_id_set instead would
+    # report ok for an expired key, which is the exact lie this tool exists to
+    # prevent.
+    result["status"] = "ok" if verified else "broken"
+
+    if verified:
+        result["reason"] = None
+        result["next_command"] = None
+    else:
+        result["reason"] = reason
+        result["next_command"] = (
+            "gpg --list-secret-keys --keyid-format=long   "
+            "# confirm %s is present and usable" % key_id)
+    return result
+
+
+# Exit codes are distinct per state so a caller can branch without parsing.
+# 0 means, and only means, a round trip completed.
+_EXIT = {"ok": 0, "broken": 1, "not_configured": 2, "gpg_absent": 3}
+
+_HEADLINE = {
+    "ok": "SIGNED    receipts from this machine carry a verifiable origin",
+    "broken": "BROKEN    receipts are being emitted UNSIGNED, silently",
+    "not_configured": "UNSIGNED  receipts prove integrity but NOT origin",
+    "gpg_absent": "UNSIGNED  signing is unavailable on this machine",
+}
+
+
+def render(result):
+    """Human-readable report. Contains no gpg transcript, by construction."""
+    status = result["status"]
+    lines = ["Receipt signing: %s" % _HEADLINE[status], ""]
+
+    lines.append("  gpg installed:      %s" % (
+        result["gpg_path"] if result["gpg_installed"] else "NO"))
+    lines.append("  LOKI_PROOF_GPG_KEY: %s" % (
+        result["key_id"] if result["key_id_set"] else "not set"))
+    lines.append("  sign+verify proof:  %s" % (
+        "PASS (round trip completed)" if result["round_trip_verified"]
+        else "not proven"))
+
+    if result.get("reason"):
+        lines += ["", "  Why: %s" % result["reason"]]
+
+    if status == "broken":
+        lines += [
+            "",
+            "  A key is configured but cannot sign. The proof generator treats",
+            "  signing as best-effort and swallows this failure, so receipts",
+            "  keep emitting UNSIGNED with no error. Nothing else reports it.",
+        ]
+    elif status == "not_configured":
+        lines += [
+            "",
+            "  Nothing is broken. Signing is opt-in and off. Turn it on to prove",
+            "  a receipt came from you and not merely that its bytes are intact.",
+        ]
+
+    if result.get("next_command"):
+        lines += ["", "  Next: %s" % result["next_command"]]
+
+    return "\n".join(lines)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Report whether this machine can produce SIGNED receipts.")
+    parser.add_argument("--json", action="store_true",
+                        help="emit the result as JSON")
+    args = parser.parse_args(argv)
+
+    result = evaluate()
+    if args.json:
+        print(json.dumps(result, indent=2, sort_keys=True))
+    else:
+        print(render(result))
+    return _EXIT[result["status"]]
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/verify-demo.sh

@@ -0,0 +1,223 @@
+#!/usr/bin/env bash
+#
+# Zero-cost demonstration of the verification chain, on receipts it builds
+# itself. The point a prospective user cannot otherwise see without paying for
+# a full build: this system re-checks its own output, and says so honestly when
+# a receipt does not hold up.
+#
+#   tools/verify-demo.sh [--keep]
+#
+# WHAT MAKES THIS HONEST, AND WHY IT IS BUILT THIS WAY.
+#
+# Every verdict below is printed by the REAL tool, verbatim. Nothing here
+# echoes a "VERIFIED" of its own. A demo that printed its own verdicts would
+# keep printing them after the verifier broke -- it would be a claim about the
+# product rather than an exercise of it, which is the same defect the tools it
+# demonstrates exist to prevent. So each step runs the actual script, shows the
+# actual output, and asserts the actual exit code. If the chain regresses, this
+# fails; that is deliberate, and makes it a smoke test as well as a demo.
+#
+# The receipts are SYNTHETIC. A scratch git repo with one commit and one
+# uncommitted edit is created in a tempdir, and the real proof generator is run
+# over it. Synthetic means no build ran, no provider was contacted and no money
+# was spent -- it does NOT mean the receipt is fake. It is a genuine receipt
+# about a trivially small piece of real work, which is exactly what lets the
+# real verifier reach a real VERIFIED instead of a hedge.
+#
+# The scratch repo is a fresh mktemp -d. Nothing is written inside the user's
+# own .loki, and the demo never touches global git config.
+
+set -uo pipefail
+
+KEEP=0
+for arg in "$@"; do
+    case "$arg" in
+        --keep) KEEP=1 ;;
+        -h|--help) sed -n '2,28p' "$0" | sed 's/^#\{1,2\} \{0,1\}//'; exit 0 ;;
+        *) echo "verify-demo: unknown argument: $arg" >&2; exit 64 ;;
+    esac
+done
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$HERE/.." && pwd)"
+
+GENERATOR="$ROOT/autonomy/lib/proof-generator.py"
+ATTEST="$HERE/receipt-attest.py"
+GATE="$HERE/ci-gate.py"
+
+# Requirement: name the missing tool and stop. A demo that skipped a step and
+# still reported success would be asserting a capability it never exercised.
+missing=0
+for tool in "$GENERATOR" "$ATTEST" "$GATE"; do
+    if [ ! -f "$tool" ]; then
+        echo "verify-demo: required tool missing: $tool" >&2
+        missing=1
+    fi
+done
+if ! command -v git >/dev/null 2>&1; then
+    echo "verify-demo: required tool missing: git" >&2
+    missing=1
+fi
+if [ "$missing" -ne 0 ]; then
+    echo "verify-demo: cannot demonstrate the verification chain with a tool absent" >&2
+    exit 1
+fi
+
+SCRATCH="$(mktemp -d "${TMPDIR:-/tmp}/loki-verify-demo-XXXXXX")"
+
+cleanup() {
+    if [ "$KEEP" -eq 1 ]; then
+        echo ""
+        echo "scratch kept at: $SCRATCH"
+    else
+        rm -rf "$SCRATCH"
+    fi
+}
+trap cleanup EXIT
+
+rule() { printf '%s\n' "------------------------------------------------------------"; }
+
+step_failed() {
+    echo ""
+    echo "verify-demo: FAILED -- $1" >&2
+    echo "verify-demo: the verification chain did not behave as this demo claims." >&2
+    exit 1
+}
+
+cat <<BANNER
+============================================================
+ Loki Mode -- verification chain demo
+============================================================
+
+ THESE RECEIPTS ARE SYNTHETIC.
+
+ No build was run. No provider was contacted. No money was
+ spent. This creates a scratch git repository, generates a
+ real receipt over it with the real generator, and then runs
+ the real verification tools against that receipt.
+
+ Every verdict below is printed by the tool named above it.
+ Nothing in this script prints a verdict of its own.
+
+ scratch workspace: $SCRATCH
+BANNER
+
+# ---------------------------------------------------------------------------
+# Build the synthetic workspace: a real repo, a real commit, a real edit.
+# Small, but genuinely present on disk, which is what the verifier re-derives
+# the receipt's git facts from.
+# ---------------------------------------------------------------------------
+cd "$SCRATCH" || step_failed "could not enter the scratch workspace"
+
+git init -q . 2>/dev/null || step_failed "could not create the scratch git repository"
+# Repo-local only. The user's global git identity is never touched.
+git config user.name "loki-verify-demo" || step_failed "could not set scratch git identity"
+git config user.email "verify-demo@loki.invalid" || step_failed "could not set scratch git identity"
+
+printf 'print("hello")\n' > app.py
+git add app.py || step_failed "could not stage the scratch file"
+git commit -qm "synthetic baseline" || step_failed "could not commit the scratch baseline"
+printf 'print("goodbye")\n' >> app.py
+
+mkdir -p .loki/proofs
+
+echo ""
+rule
+echo "STEP 1 of 3 -- generate a receipt over the synthetic workspace"
+echo "  \$ autonomy/lib/proof-generator.py --out-dir .loki/proofs/good"
+rule
+if ! python3 "$GENERATOR" --loki-dir .loki --out-dir .loki/proofs/good \
+        --provider claude --quiet; then
+    step_failed "the real proof generator did not produce a receipt"
+fi
+GOOD="$SCRATCH/.loki/proofs/good/proof.json"
+[ -f "$GOOD" ] || step_failed "the generator reported success but wrote no proof.json"
+echo "wrote $(basename "$GOOD") ($(wc -c < "$GOOD" | tr -d ' ') bytes)"
+
+# ---------------------------------------------------------------------------
+# 2. The honest receipt verifies.
+# ---------------------------------------------------------------------------
+echo ""
+rule
+echo "STEP 2 of 3 -- verify the untouched receipt"
+echo "  \$ tools/receipt-attest.py .loki/proofs/good/proof.json"
+rule
+python3 "$ATTEST" "$GOOD"
+good_exit=$?
+if [ "$good_exit" -ne 0 ]; then
+    step_failed "an untouched receipt did not attest cleanly (exit $good_exit, expected 0)"
+fi
+echo ""
+echo "  -> exit 0. Every scored axis was checked here, and passed."
+
+# ---------------------------------------------------------------------------
+# 3. Tamper with a recorded FACT, not the formatting. The integrity hash is
+#    taken over canonicalized bytes, so re-indenting alone proves nothing;
+#    changing a claim the receipt makes is the case worth showing.
+# ---------------------------------------------------------------------------
+mkdir -p "$SCRATCH/.loki/proofs/tampered"
+python3 - "$GOOD" "$SCRATCH/.loki/proofs/tampered/proof.json" <<'PY' || step_failed "could not write the tampered receipt"
+import json, sys
+src, dst = sys.argv[1], sys.argv[2]
+proof = json.loads(open(src).read())
+# Inflate the recorded file count: the receipt now claims more work than the
+# repository contains. This is the realistic forgery, and it is a value inside
+# the hashed body rather than a formatting change.
+proof["facts"]["git"]["diff"]["count"] = 999
+open(dst, "w").write(json.dumps(proof, indent=2))
+PY
+
+echo ""
+rule
+echo "STEP 3 of 3 -- tamper with the receipt, then re-verify"
+echo "  edited facts.git.diff.count: 1 -> 999 (claims work that is not there)"
+echo "  \$ tools/receipt-attest.py .loki/proofs/tampered/proof.json"
+rule
+python3 "$ATTEST" "$SCRATCH/.loki/proofs/tampered/proof.json"
+bad_exit=$?
+if [ "$bad_exit" -eq 0 ]; then
+    step_failed "a tampered receipt attested as clean (exit 0) -- the verifier did not catch it"
+fi
+echo ""
+echo "  -> exit $bad_exit. Caught, with the reason printed above."
+
+# ---------------------------------------------------------------------------
+# 4. The gate refuses. A verdict a human reads is not a gate; an exit code CI
+#    branches on is. Only the tampered receipt is left in place.
+# ---------------------------------------------------------------------------
+# Moved aside rather than deleted: the gate must see ONLY the tampered receipt
+# (it attests the newest one under .loki/proofs/*), while --keep still leaves
+# the good receipt on disk for anyone -- or any test -- wanting to re-hash it
+# and confirm the digest printed above came from these exact bytes.
+mkdir -p "$SCRATCH/generated"
+mv "$SCRATCH/.loki/proofs/good/proof.json" "$SCRATCH/generated/proof.json" \
+    || step_failed "could not set aside the good receipt"
+rm -rf "$SCRATCH/.loki/proofs/good"
+
+echo ""
+rule
+echo "AND THE GATE REFUSES TO PASS"
+echo "  with only the tampered receipt present:"
+echo "  \$ tools/ci-gate.py . --require-receipt"
+rule
+python3 "$GATE" "$SCRATCH" --require-receipt
+gate_exit=$?
+if [ "$gate_exit" -eq 0 ]; then
+    step_failed "the CI gate passed (exit 0) on a tampered receipt"
+fi
+echo ""
+echo "  -> exit $gate_exit. A CI job branching on this exit code stops here."
+
+cat <<'SUMMARY'
+
+============================================================
+ Every verdict above was printed by the real tool, over
+ receipts generated on this machine seconds ago.
+
+ Reminder: SYNTHETIC receipts. No build ran, no provider was
+ contacted, no money was spent. This demonstrates the
+ verification chain; it does not certify any real work.
+============================================================
+SUMMARY
+
+exit 0