loki-mode 9.4.0 → 9.6.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 v9.4.0
+# Loki Mode v9.6.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
 
 ---
 
-**v9.4.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v9.6.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-9.4.0
+9.6.0

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "9.4.0"
+__version__ = "9.6.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="9.4.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="9.6.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=232D7DEBCB9B9EB464756E2164756E21
+//# debugId=86F920657B9F1C4064756E2164756E21

package/mcp/__init__.py

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "9.4.0",
+  "version": "9.6.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": "9.4.0",
+  "version": "9.6.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-badge.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Render a ci-gate verdict as a shields.io badge, without laundering it.
+
+WHY THIS EXISTS. `ci-gate.py --json` already emits an honest three-state
+verdict, but nobody reads a JSON body on a README. They read a badge, at a
+glance, and act on the colour alone. That glance is the last place the
+three-state distinction can be lost, and it is the easiest place to lose it:
+shields.io has exactly two colours everyone reaches for, and a two-colour
+rendering of a three-state verdict has to fold one state into another.
+
+Folding UNEVALUABLE into PASS is the failure this file exists to prevent. It
+puts a green badge on a README at exactly the moment the gate went blind --
+the loudest possible reassurance backed by the least possible evidence. So
+UNEVALUABLE gets its own colour, and a test asserts that colour is neither in
+the green family nor equal to whatever the pass path renders.
+
+THREE RULES THIS ENFORCES BEYOND COLOUR:
+
+  Never invent a verdict. Empty stdin and malformed stdin are not states of
+  the gate, they are the absence of a reading. Both exit 2 and render an
+  "input" badge. Neither can render a pass.
+
+  Trust nothing the input contradicts. The payload carries `state` (which
+  picks the colour) and `exit_code` (which this process re-raises). If they
+  disagree -- UNEVALUABLE alongside exit 0 -- the payload is not a verdict
+  this tool recognises, and it is rejected rather than half-believed.
+
+  A measured zero survives. `exit_code` 0 is the PASS code, and it is falsy.
+  `payload.get("exit_code") or UNEVALUABLE` would silently convert every
+  passing gate into a blind one. Read it with `is None`, never truthiness.
+
+Usage:
+  tools/ci-gate.py <ws> --max-usd 5 --json | tools/gate-badge.py [--label NAME]
+
+Exit: mirrors the input verdict (0 pass, 1 failed, 2 unevaluable), so a shell
+pipe cannot turn a failure into a success. 64 on a usage error.
+"""
+
+import argparse
+import json
+import sys
+
+PASS, FAIL, UNEVALUABLE = 0, 1, 2
+
+# The colour and the words for each state. Deliberately NOT a green/red pair:
+# "orange" is the whole point of the file, and the message names the actual
+# state rather than a generic "error" that reads the same for all three.
+_BADGE = {
+    "PASS": ("passing", "brightgreen"),
+    "FAIL": ("failing", "red"),
+    "UNEVALUABLE": ("unevaluable", "orange"),
+}
+
+# A verdict this tool did not receive, rendered so a reader can tell "the gate
+# is blind" from "nobody told me what the gate said".
+_NO_INPUT = ("no gate verdict on stdin", "lightgrey")
+
+
+class _Parser(argparse.ArgumentParser):
+    """A typo must never read as a blind gate.
+
+    argparse exits 2 on a usage error, and 2 here means "could not be
+    checked" -- so a mistyped flag would be indistinguishable from a gate
+    that genuinely went dark, and an operator would go hunting for broken
+    instrumentation that was never broken.
+    """
+
+    def error(self, message):
+        self.print_usage(sys.stderr)
+        sys.stderr.write("%s: error: %s\n" % (self.prog, message))
+        raise SystemExit(64)
+
+
+def badge(payload, label="gate"):
+    """Map one ci-gate verdict onto a shields.io endpoint body.
+
+    Returns (body, exit_code). Raises ValueError when the payload is not a
+    verdict, so no caller can fall through into a rendered pass.
+    """
+    if not isinstance(payload, dict):
+        raise ValueError("expected a ci-gate JSON object, got %s"
+                         % type(payload).__name__)
+
+    state = payload.get("state")
+    code = payload.get("exit_code")
+
+    if state not in _BADGE:
+        raise ValueError("unrecognised gate state: %r" % (state,))
+    # `is None` and an explicit int check, not truthiness: 0 is the PASS code
+    # and is falsy, and `True` is an int to Python but not an exit code.
+    if code is None or not isinstance(code, int) or isinstance(code, bool):
+        raise ValueError("gate payload carries no usable exit_code: %r"
+                         % (code,))
+
+    # The two fields must agree. A payload saying UNEVALUABLE while carrying
+    # exit 0 is either corrupt or hand-edited toward green; believing half of
+    # it would let the half that is green through.
+    expected = {"PASS": PASS, "FAIL": FAIL, "UNEVALUABLE": UNEVALUABLE}[state]
+    if code != expected:
+        raise ValueError(
+            "gate payload disagrees with itself: state=%s implies exit %d "
+            "but exit_code=%d" % (state, expected, code))
+
+    message, color = _BADGE[state]
+    return ({"schemaVersion": 1, "label": label, "message": message,
+             "color": color}, code)
+
+
+def main(argv=None):
+    ap = _Parser(
+        description="Render a ci-gate --json verdict as a shields.io badge.")
+    ap.add_argument("--label", default="gate",
+                    help="badge label text; default 'gate'")
+    # No positional. A stray path argument is a usage error (64), never a file
+    # this tool silently judges.
+    args = ap.parse_args(argv)
+
+    raw = sys.stdin.read()
+    if not raw.strip():
+        # Absence of a reading, not a reading of absence. Rendering a pass
+        # here would mean an unplugged pipe certifies a merge.
+        message, color = _NO_INPUT
+        print(json.dumps({"schemaVersion": 1, "label": args.label,
+                          "message": message, "color": color}))
+        sys.stderr.write("gate-badge: empty stdin -- pipe `ci-gate.py --json` "
+                         "into this tool. No verdict was read, so none is "
+                         "rendered.\n")
+        return UNEVALUABLE
+
+    try:
+        body, code = badge(json.loads(raw), args.label)
+    except (ValueError, TypeError) as exc:
+        message, color = _NO_INPUT
+        print(json.dumps({"schemaVersion": 1, "label": args.label,
+                          "message": message, "color": color}))
+        sys.stderr.write("gate-badge: %s\n" % exc)
+        return UNEVALUABLE
+
+    print(json.dumps(body))
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/gate-status.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""Is this repo's merge gate actually set up and working? One screen.
+
+WHY THIS EXISTS. The gate line ships as eight separate tools, each honest on
+its own axis: policy-load.py validates the policy file, baseline-pin.py holds
+the cost reference, signing-status.py proves the keyring can sign,
+cost-history.py holds the measured trend, ci-gate.py enforces the lot. Every
+one of them answers a question an operator did not ask. The question they
+actually ask, at the moment they need it -- before a release, after inheriting
+a repo, when a green check stops being believable -- is one question:
+
+    is the gate ON, and would it do anything right now?
+
+Nobody could answer it without running five commands and knowing how to read
+five different exit conventions. So the honest answer to "is the gate working"
+was, in practice, "somebody said it was". That is the exact shape this repo has
+paid for fifteen times over: an assurance nobody re-derived.
+
+NOTHING HERE RE-IMPLEMENTS A CHECK. Each line is produced by invoking the tool
+that owns that rule as a subprocess (sys.executable + the tool path) and
+mapping its exit code. A second copy of a rule is how the rule drifts, and this
+repo proved that five times over with provider lists alone. Concretely: this
+file does NOT know what makes a policy valid, what counts as baseline drift,
+what proves a keyring can sign, or what makes a cost record measured. It knows
+only which tool owns each question.
+
+THREE STATES, NEVER A BOOLEAN, on every line:
+
+    OK        the owning tool checked, and the answer is yes
+    PROBLEM   the owning tool checked, and the answer is no
+    UNKNOWN   the owning tool could not check, or is not on disk
+
+UNKNOWN is the state this whole file exists to keep. "We checked and it is
+fine" and "we could not check" are opposite facts about the world, and a status
+screen is exactly where the second silently becomes the first -- a dash, a
+blank cell, a skipped row. Absent is not zero, and unmeasured is not OK.
+
+A MISSING COMPOSED TOOL READS "unavailable" AND POISONS THE VERDICT. If
+signing-status.py is not on disk, this cannot report on signing, so it says so
+and the overall verdict is not OK. A status screen that drops a line it could
+not produce and still says "healthy" is reporting on a smaller repo than the
+one it was pointed at. That is the tarball-assertion defect again: a check
+reporting a pass without having checked.
+
+THE VERDICT IS WEAKEST-LINK. Never a count, never a percentage, never "4 of 5".
+A score cannot answer "is the gate working", because the one axis that is
+blind is the one that matters. UNKNOWN outranks PROBLEM in the verdict for the
+same reason ci-gate.py ranks them that way: told PROBLEM, an operator fixes the
+named thing, re-runs, sees green, and is still blind on the dead axis.
+
+READ-ONLY, AND IT SAYS SO. Every composed tool is invoked in a reporting mode
+that starts no run, spends nothing, and contacts no provider: policy-load
+reads a file, baseline-pin `show` reads a pin, signing-status round-trips
+against the local keyring only, cost-history `report` reads recorded history,
+and ci-gate is NOT executed at all -- the "would the gate run" line is answered
+from whether a policy implies flags, because running the real gate would be the
+one composed call that is not free.
+
+Usage:
+  tools/gate-status.py [workspace] [--json] [--policy .loki-policy.json]
+
+Exit: 0 every component checked and healthy, 1 a component checked and is not,
+2 a component could not be checked (including a missing tool), 66 the
+workspace path does not exist.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+OK, PROBLEM, UNKNOWN = "OK", "PROBLEM", "UNKNOWN"
+
+# Exit codes, per the repo-wide tools/ convention.
+EXIT_OK, EXIT_PROBLEM, EXIT_UNKNOWN, EXIT_USAGE, EXIT_MISSING = 0, 1, 2, 64, 66
+
+_VERDICT_EXIT = {OK: EXIT_OK, PROBLEM: EXIT_PROBLEM, UNKNOWN: EXIT_UNKNOWN}
+
+# Module-level so a test can point one at a nonexistent path and assert that a
+# missing component reads unavailable AND drags the verdict off OK.
+POLICY_LOAD = os.path.join(_HERE, "policy-load.py")
+BASELINE_PIN = os.path.join(_HERE, "baseline-pin.py")
+SIGNING_STATUS = os.path.join(_HERE, "signing-status.py")
+COST_HISTORY = os.path.join(_HERE, "cost-history.py")
+
+
+class _Usage(argparse.ArgumentParser):
+    """argparse defaults a usage error to exit 2, which here means "could not
+    be checked" -- a typo in a flag would read as a blind gate rather than as
+    the operator error it is. 64 keeps those two facts distinct."""
+
+    def error(self, message):
+        self.print_usage(sys.stderr)
+        sys.stderr.write("%s: error: %s\n" % (self.prog, message))
+        raise SystemExit(EXIT_USAGE)
+
+
+def _line(component, state, detail):
+    return {"component": component, "state": state, "detail": detail}
+
+
+def _invoke(tool, argv):
+    """Run a component tool read-only. Returns (returncode, stdout, stderr) or
+    None when the tool is not on disk. Never recomputes the tool's rule."""
+    if not os.path.isfile(tool):
+        return None
+    try:
+        proc = subprocess.run([sys.executable, tool] + argv,
+                              capture_output=True, text=True)
+    except OSError as exc:
+        return (None, "", str(exc))
+    return (proc.returncode, proc.stdout, proc.stderr)
+
+
+def _unavailable(component, tool):
+    return _line(component, UNKNOWN,
+                 "unavailable: %s is not on disk, so this axis was never "
+                 "checked -- absent is not OK" % os.path.basename(tool))
+
+
+def _first_line(*texts):
+    for text in texts:
+        for raw in (text or "").splitlines():
+            if raw.strip():
+                return raw.strip()
+    return "no detail reported"
+
+
+def check_policy(policy_file):
+    """Is a merge policy file present and valid? policy-load.py owns the rule."""
+    got = _invoke(POLICY_LOAD, ["--file", policy_file, "--as-args"])
+    if got is None:
+        return _unavailable("policy", POLICY_LOAD)
+    rc, out, err = got
+    if rc is None:
+        return _line("policy", UNKNOWN, "could not run policy-load.py: %s" % err)
+    if rc == 0:
+        return _line("policy", OK,
+                     "%s is valid and enforces: %s" % (policy_file, out.strip()))
+    if rc == 1:
+        # policy-load's own words: missing file, unknown key, bad value, or a
+        # policy that enforces nothing. All are "checked, and it is not set up".
+        return _line("policy", PROBLEM, _first_line(err, out))
+    return _line("policy", UNKNOWN,
+                 "policy-load.py exited %d, which is not a verdict: %s"
+                 % (rc, _first_line(err, out)))
+
+
+def check_baseline(pin_file):
+    """Is a cost baseline pinned and undrifted? baseline-pin.py owns the rule,
+    including what counts as drift (raw-bytes sha256, not the receipt's own
+    canonical digest). That distinction is not restated here."""
+    got = _invoke(BASELINE_PIN, ["show", "--file", pin_file, "--json"])
+    if got is None:
+        return _unavailable("baseline", BASELINE_PIN)
+    rc, out, err = got
+    if rc is None:
+        return _line("baseline", UNKNOWN,
+                     "could not run baseline-pin.py: %s" % err)
+    if rc == 0:
+        return _line("baseline", OK, _first_line(err))
+    if rc == 1:
+        # No pin at all, or a pin whose receipt drifted since. Both are
+        # "checked, and there is no trustworthy baseline".
+        return _line("baseline", PROBLEM, _first_line(err, out))
+    return _line("baseline", UNKNOWN,
+                 "baseline-pin.py exited %d, which is not a verdict: %s"
+                 % (rc, _first_line(err, out)))
+
+
+def check_signing():
+    """Can this machine sign receipts? signing-status.py owns the rule, and it
+    already refuses to collapse its four states into a boolean. Its
+    not_configured (2) and gpg_absent (3) are NOT problems -- signing is opt-in
+    and nothing is broken -- but neither are they proof of origin, so they read
+    UNKNOWN here rather than OK. Only a completed sign+verify round trip is OK."""
+    got = _invoke(SIGNING_STATUS, ["--json"])
+    if got is None:
+        return _unavailable("signing", SIGNING_STATUS)
+    rc, out, err = got
+    if rc is None:
+        return _line("signing", UNKNOWN,
+                     "could not run signing-status.py: %s" % err)
+    try:
+        detail = json.loads(out)
+    except ValueError:
+        detail = None
+    status = detail.get("status") if isinstance(detail, dict) else None
+    reason = (detail or {}).get("reason") if isinstance(detail, dict) else None
+
+    if rc == 0 and status == "ok":
+        return _line("signing", OK,
+                     "sign+verify round trip completed: receipts carry origin")
+    if rc == 1 and status == "broken":
+        return _line("signing", PROBLEM,
+                     "a key is configured but cannot sign, so receipts emit "
+                     "UNSIGNED silently: %s" % (reason or "no reason reported"))
+    if rc == 2 and status == "not_configured":
+        return _line("signing", UNKNOWN,
+                     "signing is opt-in and off (LOKI_PROOF_GPG_KEY unset): "
+                     "receipts prove integrity but NOT origin")
+    if rc == 3 and status == "gpg_absent":
+        return _line("signing", UNKNOWN,
+                     "no gpg on PATH, so origin cannot be proven here")
+    return _line("signing", UNKNOWN,
+                 "signing-status.py exited %d with status %r, which is not a "
+                 "verdict: %s" % (rc, status, _first_line(err, out)))
+
+
+def check_cost_history(history_file):
+    """Is there measured cost history? cost-history.py owns the rule, including
+    what counts as measured (it imports record_is_measured; this file does not
+    restate that predicate, and must not)."""
+    got = _invoke(COST_HISTORY, ["report", "--file", history_file, "--json"])
+    if got is None:
+        return _unavailable("cost_history", COST_HISTORY)
+    rc, out, err = got
+    if rc is None:
+        return _line("cost_history", UNKNOWN,
+                     "could not run cost-history.py: %s" % err)
+    try:
+        detail = json.loads(out)
+    except ValueError:
+        detail = None
+    if rc == 0 and isinstance(detail, dict):
+        runs = detail.get("measured")
+        median = detail.get("median_usd")
+        # A measured ZERO must survive as 0, so both of these ask `is None`,
+        # never falsy. `if not runs` would report a real count of zero as an
+        # absent count, and `median or "unknown"` would render a genuine,
+        # measured $0.00 median as unknown -- the exact collapse this repo has
+        # paid for on fifteen surfaces, run in the opposite direction.
+        if runs is None:
+            return _line("cost_history", UNKNOWN,
+                         "cost-history reported no measured-run count")
+        return _line("cost_history", OK,
+                     "%d measured run(s) in %s; median $%s; direction: %s"
+                     % (runs, history_file,
+                        "UNKNOWN" if median is None else "%.4f" % median,
+                        detail.get("direction", "UNKNOWN")))
+    if rc == 1:
+        # Empty history, or history with no measured run. Zero runs is an
+        # absent measurement, which is a blind axis, not a healthy one.
+        why = detail.get("why") if isinstance(detail, dict) else None
+        return _line("cost_history", UNKNOWN,
+                     "no measured cost history: %s"
+                     % (why or _first_line(err) or history_file))
+    return _line("cost_history", UNKNOWN,
+                 "cost-history.py exited %d, which is not a verdict: %s"
+                 % (rc, _first_line(err, out)))
+
+
+def check_would_run(policy_line):
+    """Would the gate do anything right now?
+
+    Answered from the policy line, NOT by executing ci-gate.py: running the
+    real gate is the one composed call that is not free, and this tool promises
+    to spend nothing. A gate invoked with no flags enforces nothing while
+    looking configured -- ci-gate.py's own docstring calls that vacuously
+    green -- so an unusable policy means the gate would not run.
+    """
+    if policy_line["state"] == OK:
+        return _line("would_run", OK,
+                     "yes: ci-gate would enforce the loaded policy on the next "
+                     "run (not executed here -- this tool spends nothing)")
+    if policy_line["state"] == PROBLEM:
+        return _line("would_run", PROBLEM,
+                     "no: the policy does not load, so ci-gate would run with "
+                     "nothing to enforce, which is green without checking")
+    return _line("would_run", UNKNOWN,
+                 "cannot say: the policy itself could not be checked")
+
+
+def evaluate(workspace=".", policy_file=None, history_file=None):
+    """Every component, then the weakest-link verdict."""
+    root = os.path.normpath(workspace)
+    if os.path.basename(root) == ".loki":
+        root = os.path.dirname(root) or "."
+    if policy_file is None:
+        policy_file = os.path.join(root, ".loki-policy.json")
+    if history_file is None:
+        history_file = os.path.join(root, ".loki", "cost-history.jsonl")
+    pin_file = os.path.join(root, ".loki", "baseline.json")
+
+    policy = check_policy(policy_file)
+    lines = [policy,
+             check_baseline(pin_file),
+             check_signing(),
+             check_cost_history(history_file),
+             check_would_run(policy)]
+
+    # THE DECISION. Weakest link, UNKNOWN outranking PROBLEM. Written once,
+    # here, so a mutation of it has nowhere to hide. Never a count: "4 of 5
+    # healthy" cannot answer "is the gate working", because the blind axis is
+    # exactly the one that matters.
+    states = [line["state"] for line in lines]
+    verdict = UNKNOWN if UNKNOWN in states else (
+        PROBLEM if PROBLEM in states else OK)
+
+    return {
+        "workspace": root,
+        "components": lines,
+        "verdict": verdict,
+        "exit_code": _VERDICT_EXIT[verdict],
+        "read_only": True,
+        "headline": _HEADLINE[verdict],
+    }
+
+
+_HEADLINE = {
+    OK: "the merge gate is configured and would enforce the policy",
+    PROBLEM: "the merge gate is configured but something it checked is wrong",
+    UNKNOWN: "the merge gate cannot be fully verified from here, so it is not "
+             "known to be working",
+}
+
+
+def render(result):
+    lines = ["Merge gate status for %s" % result["workspace"],
+             "  (read-only: starts nothing, spends nothing, contacts no "
+             "provider)", ""]
+    lines.append("%-14s %-9s %s" % ("COMPONENT", "STATE", "DETAIL"))
+    for row in result["components"]:
+        lines.append("%-14s %-9s %s"
+                     % (row["component"], row["state"], row["detail"]))
+    lines += ["", "GATE: %s -- %s" % (result["verdict"], result["headline"])]
+    return "\n".join(lines)
+
+
+def main(argv=None):
+    ap = _Usage(
+        description="One-screen answer to whether this repo's merge gate is "
+                    "set up and working. Read-only: starts nothing, spends "
+                    "nothing, contacts no provider.")
+    ap.add_argument("workspace", nargs="?", default=".",
+                    help="workspace root (or its .loki dir); default .")
+    ap.add_argument("--policy", default=None,
+                    help="policy file; default <workspace>/.loki-policy.json")
+    ap.add_argument("--history", default=None,
+                    help="cost history JSONL; default "
+                         "<workspace>/.loki/cost-history.jsonl")
+    ap.add_argument("--json", action="store_true", dest="as_json",
+                    help="emit the status as JSON")
+    args = ap.parse_args(argv)
+
+    if not os.path.isdir(args.workspace):
+        sys.stderr.write("gate-status: workspace does not exist: %s\n"
+                         % args.workspace)
+        return EXIT_MISSING
+
+    result = evaluate(args.workspace, args.policy, args.history)
+    print(json.dumps(result, indent=2, sort_keys=True) if args.as_json
+          else render(result))
+    return result["exit_code"]
+
+
+if __name__ == "__main__":
+    sys.exit(main())