loki-mode 8.70.0 → 8.71.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.70.0
+# Loki Mode v8.71.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.70.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v8.71.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-8.70.0
+8.71.0

package/autonomy/loki

@@ -4137,6 +4137,85 @@ cmd_ship() {
     return 0
 }
 
+# Per-error_class remediation, shared by BOTH cmd_why paths (human + --json).
+#
+# WHY THIS IS A SHELL VARIABLE. cmd_why runs two SEPARATE python3 heredocs, so a
+# helper defined in one is invisible to the other. Copy-pasting the map into
+# both is exactly the drift this file warns against everywhere else (see the
+# GUIDE / _loki_next_action "kept in lockstep" comments). Defining it once and
+# injecting it into both makes divergence impossible rather than merely
+# discouraged.
+#
+# SCOPE. The GUIDE map keys on run STATUS (council_approved / failed / ...).
+# This keys on the LAST_ERROR error_class -- a different, orthogonal axis. A
+# `failed` run got the same "read the logs" line whether the cause was a 401 or
+# a timeout; this is what makes the two cases differ.
+#
+# run.sh WRITES the classification (_loki_classify_iteration_error, :1857) and
+# injects a heal hint naming the class (:1889), but neither carries remediation
+# text -- so there is no second surface to mirror. This is the sole home for the
+# wording. If run.sh ever gains one, keep them in lockstep.
+#
+# HONESTY. last_error_action() returns None for any class not in the map --
+# including "unknown", which run.sh writes when it will not guess. A None means
+# the caller must print the recorded brief verbatim and infer NOTHING. Never add
+# a fallback action here: a generic string on an unknown class is a fabricated
+# diagnosis wearing an action's clothes.
+read -r -d '' _LOKI_WHY_ACTIONS_PY <<'WHYACTIONS' || true
+# error_class -> (action). Each is a command or env var the reader can act on.
+LAST_ERROR_ACTIONS = {
+    "rate_limited":
+        "Wait for the provider limit to reset, then re-run: loki start <spec>",
+    "build_timeout":
+        "Raise the per-iteration limit, or narrow the spec so one iteration does less:\n"
+        "LOKI_ITERATION_TIMEOUT=3600 loki start <spec>",
+    "provider_empty_output":
+        "The provider returned nothing. Check provider health first: loki doctor\n"
+        "then re-run. If doctor is clean, try another provider: LOKI_PROVIDER=<name> loki start <spec>",
+}
+
+# Auth remediation is PROVIDER-SPECIFIC and the LAST_ERROR schema records no
+# provider. So we use LOKI_PROVIDER when it is set, and when it is not we list
+# every option LABELLED rather than presenting one provider's fix as the answer.
+PROVIDER_AUTH = {
+    "claude": "claude login   (or set ANTHROPIC_API_KEY)",
+    "codex": "codex login   (or set OPENAI_API_KEY)",
+    "aider": "set the API key for your aider model (OPENAI_API_KEY / ANTHROPIC_API_KEY)",
+    "cline": "re-enter the API key in Cline's provider settings",
+    "opencode": "opencode auth login",
+}
+
+
+def last_error_action(rec, provider=""):
+    """Concrete next action for a LAST_ERROR record, or None if unrecognized.
+
+    None is a real answer: it means we have no mapped action and the caller must
+    fall back to the recorded brief verbatim. Do not turn it into a default.
+    """
+    if not isinstance(rec, dict):
+        return None
+    ec = str(rec.get("error_class") or "").strip()
+    if ec == "auth_error":
+        p = str(provider or "").strip().lower()
+        if p in PROVIDER_AUTH:
+            return "Re-authenticate %s: %s" % (p, PROVIDER_AUTH[p])
+        lines = ["Re-authenticate the provider in use (LOKI_PROVIDER is unset, so "
+                 "the provider was not recorded):"]
+        for _n in sorted(PROVIDER_AUTH):
+            lines.append("  %-9s %s" % (_n, PROVIDER_AUTH[_n]))
+        return "\n".join(lines)
+    action = LAST_ERROR_ACTIONS.get(ec)
+    if action is None:
+        return None
+    if ec == "rate_limited":
+        # retry_after is NOT in the documented schema. Read it defensively and
+        # print nothing when absent -- a placeholder would read as measured.
+        _r = rec.get("retry_after", rec.get("retry_after_seconds"))
+        if _r not in (None, ""):
+            action += "\nProvider reported retry-after: %s" % _r
+    return action
+WHYACTIONS
+
 # loki why -- actionable failure/outcome diagnosis (B5).
 # Reads the already-captured run artifacts (no new state): the terminal run state
 # (.loki/<autonomy-state>.json: status, lastExitCode, iterationCount), the durable
@@ -4173,8 +4252,11 @@ cmd_why() {
         _LOKI_WHY_STATE="$state_file" _LOKI_WHY_COMPLETION="$completion_file" \
         _LOKI_WHY_HEAD_SHA="$_why_json_head_sha" \
         _LOKI_WHY_LAST_ERROR="$loki_dir/state/LAST_ERROR.json" \
+        _LOKI_WHY_ACTIONS_PY="$_LOKI_WHY_ACTIONS_PY" \
         _LOKI_WHY_EFFICIENCY="$loki_dir/metrics/efficiency" python3 - <<'WHYJSON'
 import json, os
+# Shared per-class action map (single definition; see _LOKI_WHY_ACTIONS_PY).
+exec(os.environ.get("_LOKI_WHY_ACTIONS_PY", ""))
 def load(p):
     try:
         with open(p) as f: return json.load(f)
@@ -4235,10 +4317,38 @@ if _effdir:
     except Exception:
         _rework = None
 
+# The machine-readable surface got the raw record and no action, so every
+# consumer had to re-derive the remediation and drift from the printed report.
+# Emit the SAME mapping the human path prints, plus an explicit honesty triple
+# so a consumer can distinguish the three no-action cases instead of seeing one
+# indistinguishable null:
+#   present=False               -> no failure was recorded (NOT "it succeeded")
+#   present=True, readable=False-> a record exists but is malformed
+#   recognized=False            -> real record, class we have no action for
+_le_path = os.environ.get("_LOKI_WHY_LAST_ERROR", "")
+_le_present = bool(_le_path) and os.path.exists(_le_path)
+_le_readable = isinstance(last_error, dict) and bool(last_error)
+if _le_present and not _le_readable:
+    # load() collapses unreadable and absent into {}. Re-read to tell them
+    # apart -- reporting a malformed record as "no failure" is the exact lie
+    # this command exists to prevent.
+    try:
+        with open(_le_path) as _lf:
+            _parsed = json.load(_lf)
+        _le_readable = isinstance(_parsed, dict)
+    except Exception:
+        _le_readable = False
+_le_action = last_error_action(last_error, os.environ.get("LOKI_PROVIDER", "")) \
+    if _le_readable else None
+
 print(json.dumps({
     "state": state,
     "completion": comp,
     "last_error": last_error,
+    "last_error_present": _le_present,
+    "last_error_readable": _le_readable,
+    "last_error_recognized": _le_action is not None,
+    "last_error_action": _le_action,
     "completion_is_stale": comp_is_stale,
     "head_sha": head_sha or None,
     "rework": _rework,
@@ -4260,8 +4370,11 @@ WHYJSON
     _LOKI_WHY_CONVERGENCE="$loki_dir/council/convergence.log" \
     _LOKI_WHY_GATE="$loki_dir/signals/GATE_ESCALATION.json" \
     _LOKI_WHY_TARGET="${TARGET_DIR:-$(dirname "$loki_dir")}" \
+    _LOKI_WHY_ACTIONS_PY="$_LOKI_WHY_ACTIONS_PY" \
     _LOKI_WHY_HANDOFFS="$loki_dir/memory/handoffs" python3 - <<'WHYTXT'
 import json, os, glob
+# Shared per-class action map (single definition; see _LOKI_WHY_ACTIONS_PY).
+exec(os.environ.get("_LOKI_WHY_ACTIONS_PY", ""))
 def load(p):
     try:
         with open(p) as f: return json.load(f)
@@ -4490,11 +4603,29 @@ if _unc and os.path.exists(_unc):
 # (that would be a fake-green-adjacent lie) - using the same SUCCESS set below.
 SUCCESS_STATUSES = {"council_approved", "completion_promise_fulfilled", "complete", "completed"}
 le = {}
+_le_path = os.environ.get("_LOKI_WHY_LAST_ERROR", "")
+_le_bad = ""
 try:
-    with open(os.environ.get("_LOKI_WHY_LAST_ERROR", "")) as f:
+    with open(_le_path) as f:
         le = json.load(f)
-except Exception:
+    if not isinstance(le, dict):
+        # A bare list/string/null is not a record. Matches the isinstance guard
+        # below rather than silently rendering an empty one.
+        _le_bad = "record is a %s, expected a JSON object" % type(le).__name__
+        le = {}
+except IOError:
+    le = {}          # absent: genuinely no recorded failure. Say nothing here.
+except ValueError as _e:
+    # Present but unparseable. Reporting silence here would read as "no failure
+    # recorded", which is a different and false claim.
     le = {}
+    _le_bad = str(_e)
+if _le_bad and status not in SUCCESS_STATUSES:
+    print()
+    print(f"  Last error  : a failure record exists but could not be read.")
+    print(f"                File  : {_le_path}")
+    print(f"                Reason: {_le_bad}")
+    print(f"                Nothing is inferred from an unreadable record.")
 if isinstance(le, dict) and le.get("error_class") and status not in SUCCESS_STATUSES:
     print()
     _it = le.get("iteration")
@@ -4502,6 +4633,24 @@ if isinstance(le, dict) and le.get("error_class") and status not in SUCCESS_STAT
     print(f"  Last error  : {le.get('error_class')}{_it_s}")
     if le.get("brief"):
         print(f"                {le.get('brief')}")
+    # Per-class remediation. Naming the error_class told the user WHAT broke and
+    # nothing about what to do; the GUIDE map above is keyed on run STATUS, so a
+    # failed run got the same generic "read the logs" line whether the cause was
+    # a 401 or a timeout. This maps the CLASS to its own concrete action.
+    #
+    # Kept in lockstep with LAST_ERROR_ACTIONS in the --json path above -- the
+    # two must not drift (same norm as the GUIDE / _loki_next_action pair).
+    # run.sh classifies the error but carries NO remediation wording, so this is
+    # the sole home for these strings.
+    _act = last_error_action(le, os.environ.get("LOKI_PROVIDER", ""))
+    if _act:
+        for _i, _line in enumerate(_act.splitlines()):
+            print(f"  {'What to do  :' if _i == 0 else '             '} {_line}")
+    else:
+        # Unrecognized class: the brief above is all we honestly know. Say that
+        # rather than emitting a generic action that implies a diagnosis.
+        print("                (Unrecognized error class -- the description above is "
+              "the recorded text, verbatim. No cause is inferred.)")
 
 # Surface the latest structured handoff (already-captured context), honestly.
 hd = sorted(glob.glob(os.path.join(os.environ.get("_LOKI_WHY_HANDOFFS",""), "*.md")))

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "8.70.0"
+__version__ = "8.71.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.70.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,YV0,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"),YV0=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.71.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,YV0,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"),YV0=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 gW0=await vW0(Bun.argv.slice(2));process.exit(gW0);
 
-//# debugId=DB062AE99F2865CE64756E2164756E21
+//# debugId=C61644368E9FCF6164756E2164756E21

package/mcp/__init__.py

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "8.70.0",
+  "version": "8.71.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.70.0",
+  "version": "8.71.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/estimate-run.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""Pre-run cost estimate: what is this run likely to cost, and on what basis.
+
+WHY THIS EXISTS. cost-summary.py answers "what did that run cost" AFTER the
+fact. The PRD-shaped estimator behind `loki plan` answers "what will a build of
+this PRD cost" from PRD heuristics, before any run exists. Neither answers the
+question an operator asks when they already have history in this workspace:
+given what iterations here have ACTUALLY cost, what is N more likely to cost.
+
+THE HONESTY RULE THIS INHERITS. Unmeasured is not free. That confusion shipped
+to a user on four separate surfaces (v8.51.0 through v8.54.0). This is another
+surface reading the same records, so it obeys the same rule by importing the
+same predicate rather than restating it:
+
+  - Zero measured records means NO BASIS. The projection is None and the render
+    says so. It never prints $0.00, because a fabricated zero is exactly the
+    defect this lineage keeps paying down, and a forward-looking $0.00 is worse
+    than a backward-looking one: it invites someone to start a run believing it
+    is free.
+  - Unmeasured records are EXCLUDED from the basis, never averaged in as zero.
+    The count that informed the estimate is always stated, so a 2-of-9 basis
+    can never be mistaken for a 9-of-9 one.
+  - A single data point is labelled as a single data point. A median of one is
+    arithmetically fine and epistemically nearly worthless; saying "median"
+    without saying "of 1" is how a guess acquires unearned authority.
+  - The output is labelled an ESTIMATE with its basis. Never a guarantee.
+
+MEASURED IS NOT THE SAME AS PRICED. record_is_measured() is field-agnostic on
+purpose: a record carrying real tokens but cost_usd 0 is "measured" on the
+strength of its tokens. For a COST basis that record is useless, and averaging
+its 0 in would drag the projection toward a fabricated low -- the headline rule
+inverted. Real costs are stored raw (0.018719), so a sub-cent charge is 0.0001
+and never exactly 0; an exact zero is therefore a reliable unpriced signal.
+cost-summary.py draws the same line for the same reason. So three counts are
+reported, not two:
+
+    found     iteration-*.json records the shared reader accepted
+    measured  record_is_measured() -- carried an observed value
+    priced    measured AND cost_usd is non-zero -- the actual basis
+
+WHAT THIS DELIBERATELY DOES NOT DO. It does not derive a median ITERATION COUNT.
+One workspace's .loki/metrics/efficiency/ holds one run's iterations, so a
+"median iteration count" over it would be a median of one sample dressed up as a
+distribution. There is no multi-run archive to draw a real one from, so
+--iterations is REQUIRED. Inventing the horizon and then multiplying a real
+per-iteration cost by it would launder a guess through an honest number.
+
+Usage:
+    python3 tools/estimate-run.py --iterations 12 [WORKSPACE] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import statistics
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_REPO_ROOT = os.path.dirname(_HERE)
+_LIB = os.path.join(_REPO_ROOT, "autonomy", "lib")
+if _LIB not in sys.path:
+    sys.path.insert(0, _LIB)
+
+# THE single definition of "measured". Restating it here is how the honesty
+# rule drifts; the four surfaces that once rendered an unmeasured run as
+# "$0.00" each had their own idea of what counted.
+from efficiency_cost import record_is_measured  # noqa: E402
+
+# iteration_attribution.py already reads, filters and sorts the efficiency dir
+# (skipping malformed records rather than defaulting them to zero).
+# cost-summary.py imports it for exactly this reason: one reader of that
+# directory. A third copy would drift the same way a second predicate would.
+_ia_spec = importlib.util.spec_from_file_location(
+    "iteration_attribution", os.path.join(_LIB, "iteration_attribution.py"))
+_ia = importlib.util.module_from_spec(_ia_spec)
+_ia_spec.loader.exec_module(_ia)
+
+# Alias-keyed table: {"pricing": {"sonnet": {"input": 3.0, "output": 15.0, ...}}}
+# USD per 1M tokens. NOT the same schema as benchmarks/bench/prices.json (which
+# efficiency_cost.price_from_tokens reads, keyed models.<x>.input_per_mtok), so
+# this reads model-pricing.json directly rather than routing through it.
+PRICING_PATH = os.path.join(
+    _REPO_ROOT, "loki-ts", "data", "model-pricing.json")
+
+
+def _num(v):
+    """Non-bool int/float, else None. Never coerces junk to 0."""
+    if isinstance(v, bool) or not isinstance(v, (int, float)):
+        return None
+    return v
+
+
+def load_pricing(path=None):
+    """Return the alias -> rates map, or {} when unreadable.
+
+    A missing price table means we cannot quote a price, which is an honest
+    null. It never blocks the projection: observed cost comes from the recorded
+    cost_usd, not from this table.
+    """
+    try:
+        with open(path or PRICING_PATH, encoding="utf-8") as handle:
+            data = json.load(handle)
+    except Exception:
+        return {}
+    pricing = data.get("pricing") if isinstance(data, dict) else None
+    return pricing if isinstance(pricing, dict) else {}
+
+
+def resolve_model_now(workspace="."):
+    """The model a run started NOW would use, and the lever that chose it.
+
+    Mirrors the runner's precedence -- a pending mid-flight override file is the
+    most specific, just-requested intent and wins over the session pin. Returns
+    (model, source); (None, None) when neither lever is set, which is an honest
+    "unresolved" rather than a guessed default. Guessing here would let the
+    report assert the projection transfers when it may not.
+    """
+    override = os.path.join(workspace, ".loki", "state", "model-override")
+    try:
+        with open(override, encoding="utf-8") as handle:
+            val = handle.read().strip().lower()
+        if val:
+            return val, "model-override file"
+    except OSError:
+        pass
+    val = (os.environ.get("LOKI_SESSION_MODEL") or "").strip().lower()
+    if val:
+        return val, "LOKI_SESSION_MODEL"
+    return None, None
+
+
+def estimate(workspace=".", iterations=None, pricing_path=None):
+    """Build the estimate dict. Pure derivation, no guessing."""
+    loki_dir = os.path.join(workspace, ".loki")
+    recs = _ia._iteration_records(loki_dir)
+
+    found = len(recs)
+    measured = 0
+    cost_points = []      # priced costs only -- THE basis
+    basis_models = []     # models of the priced records, in order
+
+    for rec in recs:
+        if not record_is_measured(rec):
+            # EXCLUDED, not added as zero. Averaging an unmeasured iteration in
+            # as 0 is indistinguishable from a real measurement of 0.
+            continue
+        measured += 1
+        usd = _num(rec.get("cost_usd"))
+        # Measured on tokens but unpriced: real for token accounting, useless
+        # for a cost basis, and a fabricated low if averaged in. See module
+        # docstring.
+        if usd is None or usd == 0:
+            continue
+        cost_points.append(float(usd))
+        model = rec.get("model")
+        basis_models.append(str(model) if model else "")
+
+    # THE HONESTY GUARD. No priced history means no basis, so every downstream
+    # number is None and the render says why. Turning this into 0.0 is the
+    # "unmeasured becomes free" defect, pointed at the future.
+    median_usd = None if not cost_points else statistics.median(cost_points)
+
+    known_models = sorted({m for m in basis_models if m})
+    model_now, model_source = resolve_model_now(workspace)
+    rates = load_pricing(pricing_path).get(model_now) if model_now else None
+
+    out = {
+        "workspace": os.path.abspath(workspace),
+        "label": "ESTIMATE",
+        "iterations_found": found,
+        "iterations_measured": measured,
+        "iterations_priced": len(cost_points),
+        "basis_count": len(cost_points),
+        "has_basis": bool(cost_points),
+        "single_point_basis": len(cost_points) == 1,
+        "median_cost_per_iteration_usd": (
+            None if median_usd is None else round(median_usd, 4)),
+        "min_cost_per_iteration_usd": (
+            round(min(cost_points), 4) if cost_points else None),
+        "max_cost_per_iteration_usd": (
+            round(max(cost_points), 4) if cost_points else None),
+        "iterations_projected": iterations,
+        "projected_cost_usd": (
+            round(median_usd * iterations, 4)
+            if median_usd is not None and iterations else None),
+        "basis_models": known_models,
+        "model_now": model_now,
+        "model_now_source": model_source,
+        "model_now_price_per_mtok": (
+            {"input": rates.get("input"), "output": rates.get("output"),
+             "cache_read": rates.get("cache_read")}
+            if isinstance(rates, dict) else None),
+        "projection_transfers": None,
+        "notes": [],
+    }
+
+    n = out["notes"]
+
+    if found == 0:
+        n.append(
+            "no iteration records found in this workspace: there is NO history "
+            "to project from, so no cost is estimated (not $0.00)")
+    elif not cost_points:
+        n.append(
+            "no measured, priced iteration in %d record(s): there is NO basis "
+            "to project from, so no cost is estimated (not $0.00)" % found)
+        if measured:
+            n.append(
+                "%d of %d records carried tokens but no cost (unpriced model): "
+                "spend is unknown rather than zero, so they cannot form a basis"
+                % (measured - len(cost_points), measured))
+    else:
+        n.append(
+            "ESTIMATE based on %d measured, priced iteration(s) of %d found -- "
+            "not a guarantee" % (len(cost_points), found))
+        if len(cost_points) == 1:
+            n.append(
+                "the basis is a SINGLE data point: this is one observation "
+                "extrapolated, not a distribution, and the range is that one "
+                "point")
+        if len(cost_points) < found:
+            n.append(
+                "PARTIAL: %d of %d records did not inform the estimate "
+                "(unmeasured or unpriced), and were excluded rather than "
+                "counted as zero" % (found - len(cost_points), found))
+        if iterations is None:
+            n.append(
+                "no --iterations given and no multi-run history exists to "
+                "derive a median iteration count from: pass --iterations N for "
+                "a projection")
+
+    # MODEL TRANSFER. Naming the model is not enough -- if history was priced on
+    # a different model than the one that would run now, the per-iteration
+    # median does not carry over, and saying so is the difference between an
+    # estimate and a misleading one.
+    if cost_points:
+        if len(known_models) > 1:
+            out["projection_transfers"] = False
+            n.append(
+                "the basis MIXES models (%s): a single median across different "
+                "price points may not transfer to either" % ", ".join(known_models))
+        elif not known_models:
+            out["projection_transfers"] = None
+            n.append(
+                "the basis records name no model: whether this projection "
+                "transfers to the model that would run now is unknown")
+        elif model_now is None:
+            out["projection_transfers"] = None
+            n.append(
+                "basis model is %s; no model is pinned for a run now "
+                "(LOKI_SESSION_MODEL unset, no override file), so whether the "
+                "projection transfers is unknown" % known_models[0])
+        elif model_now != known_models[0]:
+            out["projection_transfers"] = False
+            n.append(
+                "basis model is %s but a run now would use %s (%s): this "
+                "projection MAY NOT TRANSFER" % (
+                    known_models[0], model_now, model_source))
+        else:
+            out["projection_transfers"] = True
+
+    if model_now and rates is None:
+        n.append(
+            "no price listed for %s in the pricing table: its rate is not "
+            "quoted (the projection still comes from observed cost, not price)"
+            % model_now)
+
+    return out
+
+
+def _fmt_usd(v):
+    """UNKNOWN, never $0.00, when there is nothing to report."""
+    return "UNKNOWN" if v is None else "$%.4f" % v
+
+
+def render(est):
+    """Human-readable report. The honesty lives here too, not only in the dict."""
+    lines = []
+    lines.append("Run cost ESTIMATE -- %s" % est["workspace"])
+    lines.append("")
+
+    if not est["has_basis"]:
+        lines.append("  NO BASIS: no measured, priced iteration to project from.")
+        lines.append("  Cost per iteration:  UNKNOWN")
+        lines.append("  Projected cost:      UNKNOWN")
+        lines.append("  Records found: %d  measured: %d  priced: %d"
+                     % (est["iterations_found"], est["iterations_measured"],
+                        est["iterations_priced"]))
+    else:
+        lines.append("  Basis:               %d measured, priced iteration(s) "
+                     "of %d found" % (est["basis_count"], est["iterations_found"]))
+        lines.append("  Cost per iteration:  median %s  (range %s - %s)" % (
+            _fmt_usd(est["median_cost_per_iteration_usd"]),
+            _fmt_usd(est["min_cost_per_iteration_usd"]),
+            _fmt_usd(est["max_cost_per_iteration_usd"])))
+        if est["iterations_projected"]:
+            label = "Projected for %d:" % est["iterations_projected"]
+            lines.append("  %-20s %s"
+                         % (label, _fmt_usd(est["projected_cost_usd"])))
+        else:
+            lines.append("  Projected cost:      UNKNOWN (pass --iterations N)")
+
+    basis_models = est["basis_models"]
+    lines.append("  Basis model(s):      %s"
+                 % (", ".join(basis_models) if basis_models else "not recorded"))
+    if est["model_now"]:
+        rate = est["model_now_price_per_mtok"]
+        price = ("not in pricing table" if not rate else
+                 "$%s in / $%s out per Mtok" % (rate["input"], rate["output"]))
+        lines.append("  Model now:           %s (via %s) -- %s"
+                     % (est["model_now"], est["model_now_source"], price))
+    else:
+        lines.append("  Model now:           not pinned")
+
+    lines.append("")
+    for note in est["notes"]:
+        lines.append("  - %s" % note)
+    return "\n".join(lines)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        description="Estimate what a run is likely to cost, from measured history.")
+    ap.add_argument("workspace", nargs="?", default=".")
+    ap.add_argument("--iterations", type=int, default=None,
+                    help="how many iterations to project (no multi-run history "
+                         "exists to derive this, so it is required for a "
+                         "projected total)")
+    ap.add_argument("--json", action="store_true")
+    args = ap.parse_args(argv)
+
+    est = estimate(args.workspace, args.iterations)
+    if args.json:
+        print(json.dumps(est, indent=2))
+    else:
+        print(render(est))
+    # Exit 0 either way: "no basis" is a successful, honest answer, not a tool
+    # failure. Callers read has_basis.
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())