loki-mode 8.67.0 → 8.69.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.67.0
+# Loki Mode v8.69.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.67.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v8.69.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-8.67.0
+8.69.0

package/autonomy/lib/cost-summary.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""Per-run cost summary: what this run spent, and what we failed to measure.
+
+WHY THIS EXISTS. The engine writes .loki/metrics/efficiency/iteration-N.json
+every iteration, and the only ways to read it back are a dashboard HTTP
+endpoint and a prompt-injection block. Neither answers the question an operator
+actually asks between runs: what did that cost, is it climbing, and is the
+cache working. Cache hit ratio is the number that moves cost most -- a run
+reading 90% from cache costs roughly a tenth of the same run reading fresh --
+and nothing on the CLI surfaced it.
+
+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: the codex
+dispatch recorded no tokens, the receipt said {"usd": 0.0, "available": true},
+the PROMPT said "$0.00" per iteration, and the verifier never checked). Each
+was fixed in isolation. This is a fifth surface reading the same records, so it
+obeys the same rule, by importing the same predicate rather than restating it:
+
+  - An unmeasured iteration prints UNKNOWN and is EXCLUDED from totals. Adding
+    it as zero would be indistinguishable from a real measurement of zero.
+  - When NO iteration is measured, the total reads UNKNOWN, never $0.00.
+  - measured/exists is always stated, so a partial measurement can never be
+    mistaken for a complete one. Half the iterations measured is half a number,
+    and a total presented without that ratio silently claims to be whole.
+  - A ratio over a zero denominator is UNKNOWN, not 0%. "The cache missed
+    everything" is an expensive, actionable claim; we have not earned it.
+  - A trend needs two measured points. "Flat" from one point is fabrication of
+    the same family.
+
+Definitions, stated because an unstated denominator is its own dishonesty:
+  cache hit ratio = cache_read / (input_tokens + cache_read)
+    i.e. share of everything read IN that came from cache. Same denominator as
+    iteration_attribution.prompt_block, so both surfaces report one number.
+  measured = the record carries a non-zero cost or token count
+    (efficiency_cost.record_is_measured -- the single definition).
+
+Usage:
+    python3 autonomy/lib/cost-summary.py [WORKSPACE] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+    sys.path.insert(0, _HERE)
+
+from efficiency_cost import record_is_measured  # noqa: E402
+
+# iteration_attribution.py already reads and sorts the efficiency dir, skipping
+# malformed records. Importing it keeps ONE reader of that directory; a third
+# copy would drift the same way a second honesty predicate would.
+_ia_spec = importlib.util.spec_from_file_location(
+    "iteration_attribution", os.path.join(_HERE, "iteration_attribution.py"))
+_ia = importlib.util.module_from_spec(_ia_spec)
+_ia_spec.loader.exec_module(_ia)
+
+TOKEN_FIELDS = (
+    "input_tokens",
+    "output_tokens",
+    "cache_read_tokens",
+    "cache_creation_tokens",
+)
+
+
+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 _count_iteration_files(loki_dir):
+    """How many iteration-*.json files EXIST, parseable or not.
+
+    A corrupt or partial record is skipped by the reader but still happened, so
+    it counts toward "exists". Dropping it from the denominator would shrink a
+    partial run into a complete-looking one -- exactly the mistake the
+    measured/exists ratio is here to prevent.
+    """
+    eff_dir = os.path.join(loki_dir, "metrics", "efficiency")
+    try:
+        names = os.listdir(eff_dir)
+    except OSError:
+        return 0
+    return sum(
+        1 for n in names if n.startswith("iteration-") and n.endswith(".json"))
+
+
+def _ratio(cache_read, fresh_input):
+    """cache_read / (fresh_input + cache_read), or None when nothing was read."""
+    denom = fresh_input + cache_read
+    if denom <= 0:
+        return None
+    return round(cache_read / denom, 4)
+
+
+def summarize(workspace="."):
+    """Build the summary dict. Pure derivation, no guessing."""
+    loki_dir = os.path.join(workspace, ".loki")
+    recs = _ia._iteration_records(loki_dir)
+    exists = max(_count_iteration_files(loki_dir), len(recs))
+
+    iterations = []
+    totals = dict.fromkeys(TOKEN_FIELDS, 0)
+    total_usd = 0.0
+    measured = 0
+    cost_points = []  # (iteration, usd) for measured costs only, for the trend
+
+    for rec in recs:
+        it = rec.get("iteration", "?")
+        is_measured = record_is_measured(rec)
+        row = {"iteration": it, "measured": is_measured}
+
+        if not is_measured:
+            # EXCLUDED from totals, not added as zero. These two produce an
+            # identical total on a partial run, which is why the measured/exists
+            # count below (not the total) is what proves the difference.
+            row["cost_usd"] = None
+            for f in TOKEN_FIELDS:
+                row[f] = None
+            row["cache_hit_ratio"] = None
+            iterations.append(row)
+            continue
+
+        measured += 1
+        usd = _num(rec.get("cost_usd"))
+        # UNPRICED IS NOT FREE. record_is_measured() is field-agnostic: a record
+        # with real tokens but cost_usd 0 is "measured" on the strength of its
+        # tokens, and the cost slot would then render $0.0000 -- the headline
+        # rule inverted, on a shape that actually ships. Codex tiers can record
+        # tokens with no priced cost, and the real FireLater records wrote an
+        # explicit "cost_usd": 0 rather than omitting the key.
+        #
+        # An exact zero is a reliable unpriced signal because real costs are
+        # stored raw (0.018719), so a sub-cent charge is 0.0001, never 0. Same
+        # truthiness rule record_is_measured applies to the aggregate, applied
+        # one level down. Tokens still render; only cost reads UNKNOWN.
+        if usd == 0:
+            usd = None
+        row["cost_usd"] = usd
+        if usd is not None:
+            total_usd += float(usd)
+            cost_points.append((it, float(usd)))
+        for f in TOKEN_FIELDS:
+            v = _num(rec.get(f))
+            row[f] = v
+            if v is not None:
+                totals[f] += int(v)
+        row["cache_hit_ratio"] = _ratio(
+            row.get("cache_read_tokens") or 0, row.get("input_tokens") or 0)
+        iterations.append(row)
+
+    # A measured iteration can still carry tokens but no cost (an unpriced
+    # model). Cost totals therefore key on cost_points, not on `measured`.
+    have_cost = bool(cost_points)
+
+    out = {
+        "workspace": os.path.abspath(workspace),
+        "iterations_found": exists,
+        "iterations_measured": measured,
+        "fully_measured": exists > 0 and measured == exists,
+        "total_cost_usd": round(total_usd, 4) if have_cost else None,
+        "cost_iterations_counted": len(cost_points),
+        "avg_cost_per_iteration": (
+            round(total_usd / len(cost_points), 4) if have_cost else None),
+        "cache_hit_ratio": _ratio(
+            totals["cache_read_tokens"], totals["input_tokens"]),
+        "cost_trend": _trend(cost_points),
+        "iterations": iterations,
+        "notes": [],
+    }
+    for f in TOKEN_FIELDS:
+        out["total_" + f] = totals[f] if measured else None
+
+    n = out["notes"]
+    if exists == 0:
+        n.append("no efficiency records found: nothing to summarize")
+    if not have_cost:
+        n.append(
+            "cost not measured for any iteration: total reads UNKNOWN, "
+            "not $0.00 (unmeasured is not free)")
+        if measured:
+            n.append(
+                "tokens WERE recorded but no cost was: the model is likely "
+                "unpriced, so spend is unknown rather than zero")
+    elif len(cost_points) < measured:
+        n.append(
+            "%d of %d measured iterations carried tokens but no cost "
+            "(unpriced model): the cost total excludes them"
+            % (measured - len(cost_points), measured))
+    elif measured < exists:
+        n.append(
+            "PARTIAL: %d of %d iterations measured. The total covers only the "
+            "measured ones; unmeasured iterations are excluded, not counted as "
+            "zero, so the real cost is HIGHER than shown."
+            % (measured, exists))
+    if out["cache_hit_ratio"] is None and measured:
+        n.append(
+            "cache hit ratio UNKNOWN: no input or cache-read tokens recorded "
+            "(a 0% ratio would claim a cold cache we did not observe)")
+    return out
+
+
+def _trend(points):
+    """Is cost per iteration climbing? Needs two measured points to say.
+
+    Compares the mean of the first half against the mean of the second half.
+    Deliberately coarse: the useful signal is direction, and a regression slope
+    over four noisy points would look more precise than it is.
+    """
+    if len(points) < 2:
+        return {
+            "direction": "unknown",
+            "points": len(points),
+            "detail": "need at least 2 measured iterations to compare",
+        }
+    vals = [v for _, v in points]
+    half = len(vals) // 2
+    first = sum(vals[:half]) / half
+    second = sum(vals[half:]) / len(vals[half:])
+    if first <= 0:
+        direction = "unknown"
+    elif second > first * 1.1:
+        direction = "climbing"
+    elif second < first * 0.9:
+        direction = "falling"
+    else:
+        direction = "flat"
+    return {
+        "direction": direction,
+        "points": len(vals),
+        "first_half_avg_usd": round(first, 4),
+        "second_half_avg_usd": round(second, 4),
+        "detail": "mean of first half vs second half of measured iterations",
+    }
+
+
+UNKNOWN = "UNKNOWN"
+
+
+def _usd(v):
+    return UNKNOWN if v is None else "$%.4f" % v
+
+
+def _pct(v):
+    return UNKNOWN if v is None else "%.1f%%" % (v * 100)
+
+
+def _tok(v):
+    return UNKNOWN if v is None else "{:,}".format(v)
+
+
+def render(s):
+    L = ["Cost summary", "============", "", "Workspace: " + s["workspace"], ""]
+    L.append("Iterations:  %d found, %d measured%s" % (
+        s["iterations_found"], s["iterations_measured"],
+        "" if s["fully_measured"] else "  <- PARTIAL" if s["iterations_found"]
+        else ""))
+    L.append("Total cost:  " + _usd(s["total_cost_usd"]))
+    L.append("Avg / iter:  " + _usd(s["avg_cost_per_iteration"]))
+    L.append("Cache ratio: " + _pct(s["cache_hit_ratio"])
+             + "   (cache_read / (input + cache_read))")
+    t = s["cost_trend"]
+    L.append("Cost trend:  %s (%d measured point(s))" % (
+        t["direction"].upper(), t["points"]))
+    L.append("")
+    L.append("Tokens:")
+    L.append("  input:          " + _tok(s["total_input_tokens"]))
+    L.append("  output:         " + _tok(s["total_output_tokens"]))
+    L.append("  cache read:     " + _tok(s["total_cache_read_tokens"]))
+    L.append("  cache creation: " + _tok(s["total_cache_creation_tokens"]))
+
+    if s["iterations"]:
+        L += ["", "Per iteration:"]
+        for r in s["iterations"]:
+            if not r["measured"]:
+                L.append("  iter %s: %s (excluded from totals)"
+                         % (r["iteration"], UNKNOWN))
+                continue
+            L.append("  iter %s: %s, in %s, out %s, cache %s" % (
+                r["iteration"], _usd(r["cost_usd"]), _tok(r["input_tokens"]),
+                _tok(r["output_tokens"]), _pct(r["cache_hit_ratio"])))
+    if s["notes"]:
+        L.append("")
+        for note in s["notes"]:
+            L.append("note: " + note)
+    return "\n".join(L)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Per-run cost summary for a Loki workspace.")
+    ap.add_argument("workspace", nargs="?", default=".",
+                    help="workspace containing .loki/ (default: .)")
+    ap.add_argument("--json", action="store_true", help="machine-readable output")
+    args = ap.parse_args(argv)
+    s = summarize(args.workspace)
+    print(json.dumps(s, indent=2) if args.json else render(s))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/autonomy/lib/efficiency_cost.py

@@ -28,6 +28,7 @@ import os
 
 __all__ = [
     "collect_efficiency",
+    "record_is_measured",
     "load_prices",
     "price_from_tokens",
     "DEFAULT_PRICES_PATH",
@@ -68,6 +69,40 @@ def _to_float(v, default=0.0):
         return default
 
 
+_MEASURED_FIELDS = (
+    "cost_usd",
+    "input_tokens",
+    "output_tokens",
+    "cache_read_tokens",
+    "cache_creation_tokens",
+)
+
+
+def record_is_measured(rec):
+    """True when ONE efficiency record actually carries an observed value.
+
+    THE SINGLE DEFINITION of "measured" for a per-iteration record. collect_
+    efficiency() applies the same rule to the SUM; anything wanting the rule
+    per iteration (cost-summary.py) must import this rather than restate it.
+    A second copy of this predicate 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 as measured.
+
+    A present file is not a measurement. A run that did work necessarily
+    consumed tokens, so all-zeros means we FAILED TO MEASURE, and unmeasured
+    must read as unknown, never as free.
+    """
+    if not isinstance(rec, dict):
+        return False
+    for key in _MEASURED_FIELDS:
+        v = rec.get(key)
+        if isinstance(v, bool):
+            continue
+        if isinstance(v, (int, float)) and v:
+            return True
+    return False
+
+
 # ---------------------------------------------------------------------------
 # efficiency collection (extracted verbatim from proof-generator.py)
 # ---------------------------------------------------------------------------
@@ -125,12 +160,17 @@ def collect_efficiency(loki_dir):
     # at least one record carried a non-zero token count or cost -- an OBSERVED
     # value, not a present file. Zero everywhere means we failed to measure, and
     # unmeasured must read as unknown.
-    _observed = any(
-        cost[k] for k in (
-            "usd", "input_tokens", "output_tokens",
-            "cache_read_tokens", "cache_creation_tokens",
-        )
-    )
+    #
+    # Applied through record_is_measured() so the aggregate rule and the
+    # per-iteration rule are literally the same code (see that docstring).
+    # The cost dict keys "usd" where a record says "cost_usd", so map across.
+    _observed = record_is_measured({
+        "cost_usd": cost["usd"],
+        "input_tokens": cost["input_tokens"],
+        "output_tokens": cost["output_tokens"],
+        "cache_read_tokens": cost["cache_read_tokens"],
+        "cache_creation_tokens": cost["cache_creation_tokens"],
+    })
     if collected and _observed:
         # Round usd to a sane precision but keep it precise (anti-pattern:
         # round suspiciously-clean numbers). 4 decimals preserves odd values.

package/autonomy/loki

@@ -906,7 +906,7 @@ show_help() {
     echo "  next             Run the right next step for you (resume / ship / why)"
     echo "  stop             Stop execution immediately"
     echo "  pause            Pause after current session"
-    echo "  resume           Resume paused execution"
+    echo "  resume           Resume a paused or interrupted run (after Ctrl-C or a crash)"
     echo "  steer \"<note>\"    Nudge a running build (needs LOKI_PROMPT_INJECTION=1)"
     echo ""
     echo "Verify / trust:"
@@ -3605,18 +3605,88 @@ cmd_steer() {
     return 0
 }
 
+# Print the one copy-pasteable command that gets an INTERRUPTED run going again,
+# naming what was found (iteration reached, when it stopped) so the user can tell
+# it is their run and not a stale directory. Returns 0 when a hint was printed,
+# 1 when there is nothing resumable (caller then prints its own message).
+#
+# Keyed on status == "interrupted" ONLY, deliberately. run.sh's load_state
+# preserves iterationCount for exactly paused|interrupted|budget_exceeded|
+# stopped and RESETS it to 0 for everything else -- including "running", which
+# is what an uncatchable SIGKILL leaves behind. Printing "resume from iteration
+# 7" on a "running" record would promise progress that load_state is about to
+# throw away, on a dev box without LOKI_DURABLE_STATE=1. A hint pointing at
+# nothing is worse than silence, so the narrow key is the point, not an
+# oversight. budget_exceeded / max_iterations_reached already get their own
+# tailored guidance from _loki_next_action (raise the cap FIRST, then resume);
+# duplicating them here would contradict it.
+#
+# Read-only: reads state, writes nothing, spends nothing.
+_loki_print_interrupted_resume_hint() {
+    local status
+    status="$(_loki_resolve_run_status 2>/dev/null)" || return 1
+    [ "$status" = "interrupted" ] || return 1
+
+    local state_file="$LOKI_DIR/autonomy-state.json"
+    if [ -n "${LOKI_SESSION_ID:-}" ] && [ -f "$LOKI_DIR/sessions/${LOKI_SESSION_ID}/autonomy-state.json" ]; then
+        state_file="$LOKI_DIR/sessions/${LOKI_SESSION_ID}/autonomy-state.json"
+    fi
+    [ -f "$state_file" ] || return 1
+
+    # iteration, lastRun and prdPath in one read. Tab-separated so a spec path
+    # containing spaces survives; python3 is already a hard dep of this file.
+    local fields iteration last_run prd_path
+    fields="$(_LOKI_RH_STATE="$state_file" python3 -c "
+import json, os
+try:
+    d = json.load(open(os.environ['_LOKI_RH_STATE']))
+except Exception:
+    d = {}
+# save_state() writes "iteration" (autonomy/run.sh:6707). Reading only
+# "iterationCount" made every REAL interrupted run report iteration 0 -- the
+# one number that makes this message reassuring rather than alarming. The
+# fixture that first exercised this used the other spelling, so the test
+# passed while the shipped path was wrong. Accept both, real key first.
+print('\t'.join([
+    str(d.get('iteration', d.get('iterationCount', 0))),
+    str(d.get('lastRun', '') or 'unknown'),
+    str(d.get('prdPath', '') or ''),
+]))" 2>/dev/null)" || return 1
+    IFS=$'\t' read -r iteration last_run prd_path <<< "$fields"
+
+    # The spec path is what makes the command RESUME this run rather than start a
+    # different one, so only interpolate it when it still exists on disk. A stale
+    # path would produce a command that fails on paste.
+    local resume_cmd="loki start"
+    if [ -n "$prd_path" ] && [ -f "$prd_path" ]; then
+        resume_cmd="loki start \"$prd_path\""
+    fi
+
+    echo -e "${YELLOW}Interrupted run found.${NC} Stopped at iteration ${BOLD}${iteration}${NC} (last activity: ${last_run})."
+    echo "Saved progress is intact. Resume it with:"
+    echo ""
+    echo -e "  ${BOLD}${resume_cmd}${NC}"
+    echo ""
+    echo -e "${DIM}It picks up from iteration ${iteration}; verification re-runs, so nothing inherits a stale PASS.${NC}"
+    return 0
+}
+
 # Resume paused execution
 cmd_resume() {
     # v7.6.2 B-13 fix: --help must print help, not act on session state.
     case "${1:-}" in
         --help|-h|help)
-            echo -e "${BOLD}Loki Mode -- resume paused session${NC}"
+            echo -e "${BOLD}Loki Mode -- resume a paused or interrupted session${NC}"
             echo ""
             echo "Usage: loki resume [options]"
             echo ""
             echo "Clears the paused flag and lets the autonomous runner continue"
             echo "from where 'loki pause' stopped it."
             echo ""
+            echo "If the run was interrupted instead (Ctrl-C, crash, closed laptop)"
+            echo "there is no flag to clear, so this prints the iteration it reached"
+            echo "and the exact command to continue from that saved state."
+            echo ""
             echo "Options:"
             echo "  --help, -h   Show this help and exit"
             echo ""
@@ -3638,8 +3708,17 @@ cmd_resume() {
     local session_running=false
     is_session_running && session_running=true
 
-    # If nothing is paused/stopped and no session is running, exit early
+    # If nothing is paused/stopped and no session is running, the run may still
+    # be RESUMABLE: a Ctrl-C / crash / closed laptop leaves no PAUSE or STOP
+    # file, only autonomy-state.json with status "interrupted" and the iteration
+    # it reached. This branch used to print "No session to resume" and send the
+    # user to `loki start`, hiding real saved progress -- and because
+    # `loki next` maps interrupted -> cmd_resume, the one command whose job is
+    # "do the right next thing" hit the same dead end. Surface it instead.
     if ! $has_pause_signal && ! $has_stop_signal && ! $session_running; then
+        if _loki_print_interrupted_resume_hint; then
+            return 0
+        fi
         echo -e "${YELLOW}No session to resume.${NC}"
         echo "Start a session with: loki start"
         exit 0
@@ -4528,6 +4607,12 @@ cmd_status() {
         echo -e "${RED}Status: STOPPED${NC}"
         echo -e "${DIM}  Clear with: loki resume${NC}"
         echo ""
+    elif _loki_print_interrupted_resume_hint; then
+        # An interrupted run (Ctrl-C / crash / closed laptop) leaves no signal
+        # file, so the two branches above miss it entirely. Same hint cmd_resume
+        # prints. elif, not a separate block: it is mutually exclusive with an
+        # explicit PAUSE/STOP, and must not stack onto the "Last run:" line.
+        echo ""
     fi
 
     # Check status file

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "8.67.0"
+__version__ = "8.69.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.67.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.69.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=C0A46D655537B91064756E2164756E21
+//# debugId=EA083A7FA264315B64756E2164756E21

package/mcp/__init__.py

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "8.67.0",
+  "version": "8.69.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.67.0",
+  "version": "8.69.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",