loki-mode 7.128.2 → 7.129.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 v7.128.2
+# Loki Mode v7.129.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -408,4 +408,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.128.2 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.129.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.128.2
+7.129.0

package/autonomy/council-v2.sh

@@ -296,7 +296,47 @@ Respond ONLY with a valid JSON object. No markdown fencing."
                 # inline prefix here is belt-and-suspenders so the carve-out is
                 # self-documenting and robust to sourcing order. No-op when caveman
                 # is absent.
-                result=$(echo "$full_prompt" | CAVEMAN_DEFAULT_MODE=off claude "${_c2_argv[@]}" -p 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                #
+                # STRUCTURED VERDICT (v8.x): when the CLI supports --json-schema,
+                # force valid JSON so the sed-carve below never has to rescue
+                # prose-wrapped output. --json-schema takes INLINE content, not a
+                # path (CLI 2.1.207 rejects a path). On any failure fall through to
+                # the plain -p call + sed-carve (unchanged, fail-closed to REJECT).
+                # Opt out LOKI_REVIEW_JSON_SCHEMA=off. claude branch only.
+                local _c2_schema_dir _c2_schema
+                _c2_schema_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+                _c2_schema="${_c2_schema_dir}/loki-ts/data/council-v2-schema.json"
+                result=""
+                if [ "${LOKI_REVIEW_JSON_SCHEMA:-on}" != "off" ] && [ -f "$_c2_schema" ] \
+                   && type loki_claude_flag_supported >/dev/null 2>&1 \
+                   && loki_claude_flag_supported "--json-schema"; then
+                    local _c2_schema_content _c2_json
+                    _c2_schema_content="$(cat "$_c2_schema" 2>/dev/null)" || _c2_schema_content=""
+                    if [ -n "$_c2_schema_content" ]; then
+                        _c2_json="$(echo "$full_prompt" | CAVEMAN_DEFAULT_MODE=off claude "${_c2_argv[@]}" -p \
+                            --json-schema "$_c2_schema_content" --output-format json 2>/dev/null)" || _c2_json=""
+                        if [ -n "$_c2_json" ]; then
+                            # Pull the schema-validated object out of the envelope.
+                            result="$(printf '%s' "$_c2_json" | python3 -c 'import sys,json
+try:
+    e=json.load(sys.stdin)
+    p=e.get("structured_output")
+    if not isinstance(p,dict):
+        r=e.get("result")
+        p=json.loads(r) if isinstance(r,str) else None
+    if isinstance(p,dict) and str(p.get("verdict","")).upper() in ("APPROVE","REJECT"):
+        sys.stdout.write(json.dumps(p))
+    else:
+        sys.exit(1)
+except Exception:
+    sys.exit(1)' 2>/dev/null)" || result=""
+                        fi
+                    fi
+                fi
+                # Fall through to the plain text call (+ sed-carve) on any miss.
+                if [ -z "$result" ]; then
+                    result=$(echo "$full_prompt" | CAVEMAN_DEFAULT_MODE=off claude "${_c2_argv[@]}" -p 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                fi
             else
                 result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
             fi

package/autonomy/lib/cr-rematerialize.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Re-materialize a `claude --json-schema --output-format json` code-review
+envelope into the LEGACY 'VERDICT: X\\nFINDINGS:\\n- [severity] description'
+text, so the downstream text parsers (_classify_verdict, _severity_is_blocking,
+_count_nonblocking_findings in autonomy/run.sh, and the TS mirror) stay
+byte-identical. This is the adapter that lets the code-review verdict path adopt
+structured output WITHOUT rewriting any consumer.
+
+Contract:
+- Reads the raw CLI envelope JSON from env _LOKI_CR_JSON (or stdin if unset).
+- Writes legacy text to the path in env _LOKI_CR_OUT (or stdout if unset).
+- FAIL-CLOSED: exits non-zero on ANY structural miss so the bash caller falls
+  through to the text path. NEVER emits 'VERDICT: PASS' on a miss.
+- T1 SAFETY (cross-field enforcement JSON Schema cannot express): if ANY finding
+  is Critical or High, the verdict is FORCED to FAIL regardless of the model's
+  emitted verdict token. A self-contradictory PASS+Critical can never be waved
+  through as non-blocking.
+
+Live-verified envelope shape (claude 2.1.207): top-level 'structured_output'
+object is the payload; 'result' is the same JSON as a string (fallback);
+'stop_reason' is 'tool_use' for a valid structured turn.
+
+Exit codes (all non-zero == fail-closed, caller falls through to text):
+  0 success   2 no input/output target   3 envelope not JSON / not a dict
+  4 wrong stop_reason   5 no usable payload   6 missing/invalid verdict
+  7 write error
+"""
+import json
+import os
+import sys
+
+_BLOCKING = {"CRITICAL", "HIGH"}
+
+
+def rematerialize(raw):
+    """Return legacy VERDICT/FINDINGS text, or raise ValueError(exit_code)."""
+    try:
+        env = json.loads(raw)
+    except Exception:
+        raise ValueError(3)
+    if not isinstance(env, dict):
+        raise ValueError(3)
+
+    # A valid structured turn ends with tool_use. A refusal / max_tokens / other
+    # stop_reason means the schema was not honored -> fail-closed.
+    if env.get("stop_reason") not in (None, "tool_use"):
+        raise ValueError(4)
+
+    payload = env.get("structured_output")
+    if not isinstance(payload, dict):
+        res = env.get("result")
+        if isinstance(res, str):
+            try:
+                payload = json.loads(res)
+            except Exception:
+                payload = None
+    if not isinstance(payload, dict):
+        raise ValueError(5)
+
+    verdict = str(payload.get("verdict", "")).strip().upper()
+    if verdict not in ("PASS", "FAIL"):
+        raise ValueError(6)
+
+    findings = payload.get("findings")
+    if not isinstance(findings, list):
+        findings = []
+
+    body = []
+    has_blocking = False
+    for f in findings:
+        if not isinstance(f, dict):
+            continue
+        sev = str(f.get("severity", "")).strip()
+        desc = str(f.get("description", "")).strip()
+        if not sev or not desc:
+            continue
+        if sev.upper() in _BLOCKING:
+            has_blocking = True
+        # Bracketed severity form matches _severity_is_blocking /
+        # _count_nonblocking_findings regexes exactly.
+        body.append("- [" + sev + "] " + desc)
+
+    # T1: a Critical/High finding forces FAIL even if the model said PASS.
+    if has_blocking:
+        verdict = "FAIL"
+
+    lines = ["VERDICT: " + verdict, "FINDINGS:"]
+    if body:
+        lines.extend(body)
+    else:
+        lines.append("- None")
+    return "\n".join(lines) + "\n"
+
+
+def main():
+    raw = os.environ.get("_LOKI_CR_JSON")
+    if raw is None:
+        raw = sys.stdin.read()
+    out_path = os.environ.get("_LOKI_CR_OUT", "")
+    if not raw:
+        return 2
+
+    try:
+        text = rematerialize(raw)
+    except ValueError as e:
+        return int(e.args[0])
+
+    if out_path:
+        try:
+            with open(out_path, "w") as fp:
+                fp.write(text)
+        except OSError:
+            return 7
+    else:
+        sys.stdout.write(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/autonomy/lib/done-recognition.sh

@@ -51,6 +51,54 @@
 _loki_done_recog_invoke() {
     local prompt="$1"
     command -v claude >/dev/null 2>&1 || return 1
+
+    # STRUCTURED VERDICT (v8.x): when the CLI supports --json-schema, force valid
+    # JSON so parse_object never has to brace-slice prose. --json-schema takes
+    # INLINE content, not a path (CLI 2.1.207 rejects a path). On any miss (flag
+    # unsupported, empty, no structured_output) fall through to the plain -p call
+    # below; parse_object then handles it and defaults to inconclusive (safe).
+    # Opt out LOKI_REVIEW_JSON_SCHEMA=off.
+    local _dr_schema_dir _dr_schema
+    _dr_schema_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+    _dr_schema="${_dr_schema_dir}/loki-ts/data/done-recognition-schema.json"
+    if [ "${LOKI_REVIEW_JSON_SCHEMA:-on}" != "off" ] && [ -f "$_dr_schema" ] \
+       && type loki_claude_flag_supported >/dev/null 2>&1 \
+       && loki_claude_flag_supported "--json-schema"; then
+        local _dr_schema_content _dr_json _dr_obj
+        _dr_schema_content="$(cat "$_dr_schema" 2>/dev/null)" || _dr_schema_content=""
+        if [ -n "$_dr_schema_content" ]; then
+            if command -v timeout >/dev/null 2>&1; then
+                _dr_json=$(CAVEMAN_DEFAULT_MODE=off timeout "${LOKI_DONE_RECOG_TIMEOUT}" \
+                    claude --dangerously-skip-permissions -p "$prompt" \
+                    --json-schema "$_dr_schema_content" --output-format json 2>/dev/null) || _dr_json=""
+            else
+                _dr_json=$(CAVEMAN_DEFAULT_MODE=off \
+                    claude --dangerously-skip-permissions -p "$prompt" \
+                    --json-schema "$_dr_schema_content" --output-format json 2>/dev/null) || _dr_json=""
+            fi
+            if [ -n "$_dr_json" ]; then
+                _dr_obj=$(printf '%s' "$_dr_json" | python3 -c 'import sys,json
+try:
+    e=json.load(sys.stdin)
+    p=e.get("structured_output")
+    if not isinstance(p,dict):
+        r=e.get("result")
+        p=json.loads(r) if isinstance(r,str) else None
+    if isinstance(p,dict) and "requirements" in p:
+        sys.stdout.write(json.dumps(p))
+    else:
+        sys.exit(1)
+except Exception:
+    sys.exit(1)' 2>/dev/null) || _dr_obj=""
+                if [ -n "$_dr_obj" ]; then
+                    printf '%s' "$_dr_obj"
+                    return 0
+                fi
+            fi
+        fi
+        # fall through to the plain text call (parse_object handles it, inconclusive-safe)
+    fi
+
     local rc=0
     local out=""
     if command -v timeout >/dev/null 2>&1; then

package/autonomy/lib/voter-agents.sh

@@ -2,7 +2,7 @@
 # autonomy/lib/voter-agents.sh -- Phase C (v7.5.20) bash side.
 #
 # Builds the JSON declaration of the council voter agents and orchestrates a
-# single `claude --agents <json> --json-schema <path>` dispatch per iteration.
+# single `claude --agents <json> --json-schema <inline-content>` dispatch per iteration.
 # Replaces the ad-hoc per-voter heuristic loop in council_aggregate_votes when
 # the locally installed Claude CLI supports both flags.
 #
@@ -176,7 +176,7 @@ loki_finding_schema_path() {
 #      --json-schema in `claude --help`. Either missing -> return 1 (fallback).
 #   2. Build the agents JSON via loki_voter_agents_json.
 #   3. Invoke `claude --dangerously-skip-permissions -p <prompt>
-#                    --agents <json> --json-schema <path>` and capture stdout.
+#                    --agents <json> --json-schema <inline-content>` and capture stdout.
 #      Any non-zero exit or empty stdout -> return 1 (fallback).
 #   4. Parse the response via python3 (no jq dependency): extract
 #      findings[].{role, vote, reason, confidence}. On parse failure -> 1.
@@ -236,6 +236,16 @@ loki_council_dispatch_agents() {
     local schema_path
     schema_path=$(loki_finding_schema_path) || return 1
 
+    # v8.x FIX: `claude --json-schema` takes the schema JSON as INLINE CONTENT,
+    # not a file path. Live-verified on CLI 2.1.207: passing a path errors with
+    # "--json-schema is not valid JSON: Unrecognized token '/'" -> rc!=0 ->
+    # fail-closed to the heuristic path, so this structured dispatch was SILENTLY
+    # DEAD (never actually schema-constrained the council). Read the file and pass
+    # its content. Fail-closed if unreadable/empty (return 1 -> heuristic path).
+    local schema_content
+    schema_content=$(cat "$schema_path" 2>/dev/null) || return 1
+    [ -n "$schema_content" ] || return 1
+
     # 3. Invoke claude. Guard against absent binary or non-zero exit.
     command -v claude >/dev/null 2>&1 || return 1
 
@@ -274,7 +284,7 @@ loki_council_dispatch_agents() {
                       env CAVEMAN_DEFAULT_MODE=off claude --dangerously-skip-permissions \
                       -p "$prompt" \
                       --agents "$agents_json" \
-                      --json-schema "$schema_path" 2>"$stderr_log") || rc=$?
+                      --json-schema "$schema_content" 2>"$stderr_log") || rc=$?
     if [ "$rc" -ne 0 ] || [ -z "$response" ]; then
         return 1
     fi

package/autonomy/loki

@@ -826,7 +826,7 @@ show_help() {
     echo "New here? Try these in order:"
     echo "  loki doctor               Check your setup is ready (a few seconds)"
     echo "  loki quickstart           Guided first build from your idea (no PRD needed)"
-    echo "  loki start ./prd.md       Build from a spec (PRD file, GitHub issue, or no arg)"
+    echo "  loki start ./prd.md       Build from a spec (PRD file, GitHub/GitLab/Jira/Azure issue, or no arg)"
     echo "  quickstart = guided first build; quick = one small task (3 iters max)."
     echo "  Docs: https://github.com/asklokesh/loki-mode  |  Report a problem: loki crash"
     echo ""
@@ -846,7 +846,7 @@ show_help() {
     echo "Commands:"
     echo ""
     echo "Build:"
-    echo "  start [SPEC]     Start a build (PRD file, GitHub issue, or no arg)"
+    echo "  start [SPEC]     Start a build (PRD file, GitHub/GitLab/Jira/Azure issue, or no arg)"
     echo "  plan <PRD-file>  Dry-run analysis: complexity, cost, execution plan"
     echo "  quickstart [idea]  Guided first build: setup, idea, template, plan, go"
     echo ""
@@ -1043,7 +1043,7 @@ show_landing() {
     echo -e "  ${CYAN}loki tour${NC}             See a real result now (no provider, no key, no spend)"
     echo -e "  ${CYAN}loki doctor${NC}           Check your setup is ready (a few seconds)"
     echo -e "  ${CYAN}loki quickstart${NC}       Guided first build from your idea (no PRD needed)"
-    echo -e "  ${CYAN}loki start ./prd.md${NC}   Build from a spec (PRD file, GitHub issue, or no arg)"
+    echo -e "  ${CYAN}loki start ./prd.md${NC}   Build from a spec (PRD file, GitHub/GitLab/Jira/Azure issue, or no arg)"
     echo "  quickstart = guided first build; quick = one small task (3 iters max)."
     echo ""
     echo -e "Need help? ${CYAN}loki help${NC} lists every command."

package/autonomy/run.sh

@@ -5911,8 +5911,15 @@ compute_codebase_signature() {
           # truncating the output and misaligning the path<->hash pairing. Drop
           # them; their removal from the list is itself the detected change.
           gitc_deleted=$(git ls-files --deleted -z 2>/dev/null | tr '\0' '\n')
+          # Exclude .loki/ AND Loki's own session-end artifacts (HANDOFF.md,
+          # USAGE.md) written+committed to the repo ROOT by the completion path
+          # (LOKI_HANDOFF / commit_session_changes, both default-on). Those are
+          # runtime OUTPUT of the session, not user codebase; counting them would
+          # make the next PRD-reuse check see a spurious "codebase changed" and
+          # flip reuse->update (the signature is persisted per-iteration BEFORE
+          # the after-loop HANDOFF write, so it can never account for them).
           gitc_paths=$( { git ls-files -z 2>/dev/null; git ls-files --others --exclude-standard -z 2>/dev/null; } \
-              | tr '\0' '\n' | grep -vE '(^|/)\.loki(/|$)' | LC_ALL=C sort -u )
+              | tr '\0' '\n' | grep -vE '(^|/)\.loki(/|$)|^HANDOFF\.md$|^USAGE\.md$' | LC_ALL=C sort -u )
           if [ -n "$gitc_deleted" ]; then
               gitc_paths=$(printf '%s\n' "$gitc_paths" | grep -vxF -f <(printf '%s\n' "$gitc_deleted") || true)
           fi
@@ -5933,6 +5940,7 @@ compute_codebase_signature() {
                          -o -name build -o -name .next -o -name target -o -name vendor \
                          -o -name __pycache__ -o -name .venv -o -name venv \) -prune -o \
               -type f -print 2>/dev/null \
+              | grep -vE '^\./(HANDOFF|USAGE)\.md$' \
               | while IFS= read -r f; do
                     local sz
                     sz=$(stat -f%z "$f" 2>/dev/null || stat -c%s "$f" 2>/dev/null || echo 0)
@@ -9658,8 +9666,16 @@ sys.stdout.write(t.strip())
             local output
             # Pass matched files explicitly (node --test globbing is
             # Node-version-sensitive); quote each so paths with spaces survive.
+            # Force --test-reporter=tap: Node 20+ made the human "spec" reporter
+            # the default for a TTY and Node 26 emits it even under capture
+            # ("i pass N" / check+cross marks) instead of the TAP "# pass N" /
+            # "ok N - " lines that BOTH the count parser below AND
+            # _loki_zero_tests_executed rely on. TAP has been stable since Node 18,
+            # so forcing it restores a deterministic, version-independent format
+            # without touching any parser. Older node ignores nothing here (tap is
+            # a valid built-in reporter on every supported version).
             output=$(cd "${TARGET_DIR:-.}" && timeout "${LOKI_GATE_TIMEOUT:-300}" \
-                         node --test "${_nt_files[@]}" 2>&1) || test_passed=false
+                         node --test --test-reporter=tap "${_nt_files[@]}" 2>&1) || test_passed=false
             # tail -14 so node's TAP summary block (# tests / # pass N / # fail N,
             # ~10 lines) survives truncation for the best-effort count parse below.
             details="node --test: $(echo "$output" | tail -14 | tr '\n' ' ')"
@@ -10994,6 +11010,39 @@ _dispatch_reviewer() {
             # then deletes its flag and emits nothing). Set inline, not via
             # the helper, so the carve-out holds even when the helper is
             # out of scope. No-op when caveman is absent.
+            # STRUCTURED VERDICT (v8.x): when the CLI supports --json-schema,
+            # force valid JSON and re-materialize the LEGACY VERDICT/FINDINGS text
+            # so every downstream consumer (_classify_verdict,
+            # _severity_is_blocking, _count_nonblocking_findings, mergeability,
+            # DA arm, aggregate.json) stays byte-identical. Fail-closed: any
+            # failure falls through to the text path below (which itself may leave
+            # an empty file -> NO_VERDICT -> inconclusive block). NEVER a PASS on a
+            # miss. --json-schema takes INLINE content, not a path (CLI 2.1.207
+            # rejects a path). Opt out with LOKI_REVIEW_JSON_SCHEMA=off.
+            local _cr_root _cr_here _cr_schema _cr_remat
+            _cr_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+            _cr_here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+            _cr_schema="${_cr_root}/loki-ts/data/code-review-schema.json"
+            _cr_remat="${_cr_here}/lib/cr-rematerialize.py"
+            if [ "${LOKI_REVIEW_JSON_SCHEMA:-on}" != "off" ] \
+               && [ -f "$_cr_schema" ] && [ -f "$_cr_remat" ] \
+               && type loki_claude_flag_supported >/dev/null 2>&1 \
+               && loki_claude_flag_supported "--json-schema"; then
+                local _cr_schema_content _cr_json _cr_rc=0
+                _cr_schema_content="$(cat "$_cr_schema" 2>/dev/null)" || _cr_schema_content=""
+                if [ -n "$_cr_schema_content" ]; then
+                    _cr_json="$(CAVEMAN_DEFAULT_MODE=off \
+                        claude "${_rv_argv[@]}" -p "$prompt_text" \
+                            --json-schema "$_cr_schema_content" \
+                            --output-format json 2>/dev/null)" || _cr_rc=$?
+                    if [ "$_cr_rc" -eq 0 ] && [ -n "$_cr_json" ] \
+                       && _LOKI_CR_JSON="$_cr_json" _LOKI_CR_OUT="$review_output" \
+                          python3 "$_cr_remat"; then
+                        return 0
+                    fi
+                fi
+                # fall through to the text path below (fail-closed)
+            fi
             CAVEMAN_DEFAULT_MODE=off \
             claude "${_rv_argv[@]}" -p "$prompt_text" \
                 --output-format text > "$review_output" 2>/dev/null

package/autonomy/verify.sh

@@ -427,6 +427,14 @@ _verify_zero_tests_executed() {
 verify_gate_tests() {
     local tree="$1"
     local timeout_s="${LOKI_GATE_TIMEOUT:-300}"
+    # Bounded-exec prefix: "timeout <secs>" / "gtimeout <secs>", or EMPTY when
+    # neither is on PATH (bare macOS, or a shadowed PATH). A bare `timeout ...`
+    # would exit 127 (command not found) and be misread as a test FAILURE ->
+    # spurious BLOCKED verdict. Degrade to running without a wall-clock cap
+    # instead. Mirrors run.sh's with_timeout discipline.
+    local _vt_bin _vt
+    _vt_bin="$(_verify_runtime_timeout_bin)"
+    if [ -n "$_vt_bin" ]; then _vt="$_vt_bin $timeout_s"; else _vt=""; fi
     local runner="none"
     local rc=0
     local out=""
@@ -434,13 +442,13 @@ verify_gate_tests() {
     if [ -f "$tree/package.json" ]; then
         if grep -q '"vitest"' "$tree/package.json" 2>/dev/null; then
             runner="vitest"
-            out="$(cd "$tree" && timeout "$timeout_s" npx vitest run 2>&1)" || rc=$?
+            out="$(cd "$tree" && $_vt npx vitest run 2>&1)" || rc=$?
         elif grep -q '"jest"' "$tree/package.json" 2>/dev/null; then
             runner="jest"
-            out="$(cd "$tree" && timeout "$timeout_s" npx jest --passWithNoTests --forceExit 2>&1)" || rc=$?
+            out="$(cd "$tree" && $_vt npx jest --passWithNoTests --forceExit 2>&1)" || rc=$?
         elif grep -q '"mocha"' "$tree/package.json" 2>/dev/null; then
             runner="mocha"
-            out="$(cd "$tree" && timeout "$timeout_s" npx mocha 2>&1)" || rc=$?
+            out="$(cd "$tree" && $_vt npx mocha 2>&1)" || rc=$?
         fi
     fi
 
@@ -480,7 +488,7 @@ verify_gate_tests() {
         if [ "$has_python" = "true" ]; then
             if command -v pytest >/dev/null 2>&1; then
                 runner="pytest"
-                out="$(cd "$tree" && timeout "$timeout_s" pytest --tb=short 2>&1)" || rc=$?
+                out="$(cd "$tree" && $_vt pytest --tb=short 2>&1)" || rc=$?
             elif command -v python3 >/dev/null 2>&1; then
                 # #139 parity: pytest ABSENT but a Python suite exists -> run it with
                 # stdlib unittest (zero third-party deps) instead of going blindly
@@ -490,7 +498,7 @@ verify_gate_tests() {
                 # a "Ran 0 tests" line detected by the zero-test guard on the run.sh
                 # mirror) so this never green-washes an empty suite.
                 runner="unittest"
-                out="$(cd "$tree" && timeout "$timeout_s" python3 -m unittest discover -p 'test_*.py' 2>&1)" || rc=$?
+                out="$(cd "$tree" && $_vt python3 -m unittest discover -p 'test_*.py' 2>&1)" || rc=$?
             else
                 # Applicable but cannot run -> inconclusive (Entanglement 2).
                 _verify_add_gate "tests" "inconclusive" "pytest" "python project detected but no pytest/python3 on PATH" "true"
@@ -502,7 +510,7 @@ verify_gate_tests() {
     if [ "$runner" = "none" ] && [ -f "$tree/go.mod" ]; then
         if command -v go >/dev/null 2>&1; then
             runner="go-test"
-            out="$(cd "$tree" && timeout "$timeout_s" go test ./... 2>&1)" || rc=$?
+            out="$(cd "$tree" && $_vt go test ./... 2>&1)" || rc=$?
         else
             _verify_add_gate "tests" "inconclusive" "go-test" "go project detected but go not on PATH" "true"
             return 0
@@ -512,7 +520,7 @@ verify_gate_tests() {
     if [ "$runner" = "none" ] && [ -f "$tree/Cargo.toml" ]; then
         if command -v cargo >/dev/null 2>&1; then
             runner="cargo-test"
-            out="$(cd "$tree" && timeout "$timeout_s" cargo test 2>&1)" || rc=$?
+            out="$(cd "$tree" && $_vt cargo test 2>&1)" || rc=$?
         else
             _verify_add_gate "tests" "inconclusive" "cargo-test" "rust project detected but cargo not on PATH" "true"
             return 0
@@ -550,7 +558,13 @@ verify_gate_tests() {
             runner="node-test"
             # Pass matched files explicitly (node --test globbing is
             # Node-version-sensitive); quote each so paths with spaces survive.
-            out="$(cd "$tree" && timeout "$timeout_s" node --test "${_nt_files[@]}" 2>&1)" || rc=$?
+            # Force --test-reporter=tap: Node 20+ defaults to the human "spec"
+            # reporter (Node 26 emits it even under capture), whose "i pass N" /
+            # check-mark lines the count parser + zero-tests detector below do NOT
+            # match; they expect TAP "# pass N" / "ok N - ". TAP is stable since
+            # Node 18, so forcing it restores a version-independent format with no
+            # parser change. Parity with autonomy/run.sh:9662.
+            out="$(cd "$tree" && $_vt node --test --test-reporter=tap "${_nt_files[@]}" 2>&1)" || rc=$?
         fi
     fi
 
@@ -564,6 +578,22 @@ verify_gate_tests() {
         return 0
     fi
 
+    # #82 (Python 3.12+): `python3 -m unittest` exits 5 (NOT 0) when it discovers
+    # ZERO tests -- e.g. a suite of pytest-style bare `def test_*` functions that
+    # unittest (TestCase-only) cannot collect. That non-zero exit would otherwise
+    # fall into the fail branch below and record tests=fail -> BLOCKED, when the
+    # honest classification is "applicable but ran no real tests" = inconclusive
+    # -> CONCERNS. Route the unittest zero-discovery case through the same guard
+    # the rc==0 path uses (its unittest arm matches "Ran 0 tests"/"NO TESTS RAN"
+    # but was unreachable behind rc==0). Scoped to unittest so pytest/go/cargo/node
+    # non-zero exits still correctly record fail.
+    if [ "$rc" -eq 5 ] && [ "$runner" = "unittest" ] \
+       && _verify_zero_tests_executed "$runner" "$out" "${_nt_files[@]:-}"; then
+        _verify_add_gate "tests" "inconclusive" "$runner" \
+            "runner ran but discovered zero tests (source_without_runnable_tests)" "true"
+        return 0
+    fi
+
     if [ "$rc" -eq 0 ]; then
         # #82: a green run that executed ZERO real tests is a mini fake-green.
         # Record it as HONEST inconclusive (forces at-least-CONCERNS), NOT pass

package/dashboard/__init__.py

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

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.128.2
+**Version:** v7.129.0
 
 ---
 
@@ -396,7 +396,7 @@ provider works inside the container. Provide auth with your Anthropic API key:
 # Run Loki Mode in Docker (Claude provider, API-key auth)
 docker run --rm -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
   -v $(pwd):/workspace -w /workspace \
-  asklokesh/loki-mode:7.128.2 start ./my-spec.md
+  asklokesh/loki-mode:7.129.0 start ./my-spec.md
 ```
 
 ##### docker compose + .env (no host install)

package/docs/RARV-C-100X-PLAN.md

@@ -0,0 +1,278 @@
+# RARV-C 100x Native-Primitives Upgrade - Plan (v8.0.0 arc)
+
+## Context
+
+Founder mandate (memory `project-rarvc-cookbook-upgrade`): we can't out-build
+Replit/Emergent/Cognition on capability. Loki's moat is loop RIGOR (never-fake-green
+RARV-C, 3-reviewer council, evidence gate), which is ON-THESIS with Anthropic's own
+long-running-agent guidance. The gap isn't rigor; it's efficiency: the loop does its
+mechanics via home-grown bash (parsing model output as TEXT, polling for budget,
+inferring cost from token math) where the installed `claude` CLI now ships NATIVE
+primitives that do the same job cheaper, faster, and without fragile parsing.
+
+This plan adopts those primitives where they MEASURABLY beat the bash equivalents, one
+per commit, bench-proven, quality never regresses. MAJOR arc (v8.0.0) on branch
+`feature/rarv-c-100x-primitives` (not yet created).
+
+**The honest headline: much of this is already shipped.** Two prior plan docs exist
+(`docs/RARV-C-LOOP-EFFICIENCY-PLAN.md`, `docs/RARV-C-CHANGE-MAP.md`, grounded to v7.121.5),
+AND the engine has since adopted several native flags. So this plan does NOT regenerate
+them. It: (1) reconciles drift to v7.128.2, (2) records what's ALREADY adopted so we don't
+rebuild it, (3) scopes the genuinely net-new work (extend structured-outputs to 4 remaining
+text-parse sites), (4) adds the missing PARITY and RELEASE sections, and consolidates into
+`docs/RARV-C-100X-PLAN.md`.
+
+---
+
+## Primary-source verification (done live this session, CLI v2.1.207)
+
+Per `reference-claude-session-flags` ("live-probe, don't trust stale training or --help
+alone"), every flag was verified by RUNNING it:
+
+| Primitive | Flag | Verified behavior (2026-07-13) |
+|---|---|---|
+| Structured output | `--json-schema <schema>` | Forces valid JSON. Envelope carries top-level `structured_output` key + `result` valid-JSON + `stop_reason:"tool_use"`. Model CANNOT emit malformed output. |
+| Cost breaker | `--max-budget-usd <amt>` | On exceed: `subtype:"error_max_budget_usd"`, `is_error:true`, exit 0 (graceful, parseable). |
+| Effort dial | `--effort low\|medium\|high\|xhigh\|max` | 5 levels; maps onto `get_rarv_tier()`. |
+| Rate-limit resilience | `--fallback-model <model>` | Present. |
+| Caching visibility | JSON envelope | `usage.cache_creation.ephemeral_1h_input_tokens` vs `ephemeral_5m` per call -> caching measurable. |
+| Cost/iter readout | JSON envelope | `total_cost_usd`, per-model `costUSD`, `cache_read_input_tokens`, `iterations[]`. |
+| Continuity | `--resume`/`--session-id`/`--fork-session` | iter0 `--session-id U0`, iterN `--resume U0`; `--session-id` reuse ERRORS. |
+
+---
+
+## What is ALREADY adopted (do NOT rebuild - ponytail rung 2)
+
+Verified in current source. The prior CHANGE-MAP predates these:
+
+- **`--effort` + `--max-budget-usd` are ALREADY plumbed** in `_loki_build_claude_auto_flags`
+  (`providers/claude.sh:143-158`), gated on `loki_claude_flag_supported` (degrades on old CLI),
+  mirrored in `loki-ts/src/providers/claude_flags.ts` (`effortForTier()`:23, `buildAutoFlags()`:150).
+  So "adopt native budget/effort breakers" is LARGELY DONE. `check_budget_limit()` (`run.sh:13035`)
+  and `is_rate_limited()` (`run.sh:12835`) still exist as the belt to the native suspenders.
+- **`--json-schema` is ALREADY adopted for the council-vote path**: `voter-agents.sh:277`
+  (`claude --agents <json> --json-schema <schema>`), wired as PREFERRED council dispatch at
+  `completion-council.sh:3137-3144` with graceful text-parse fallback (3146-3154). Schema:
+  `loki-ts/data/finding-schema.json`. TS mirror: `loki-ts/src/council/voter_agents.ts:299-327`.
+  This pair is the TEMPLATE to extend, not a greenfield build.
+- **Completion detection is already structured** via `.loki/signals/*` + `loki_complete_task`
+  MCP tool (`run.sh:13351-13369`); text-match is legacy behind `LOKI_LEGACY_COMPLETION_MATCH=true`.
+
+**Net-new structured-output work = extend the voter-agents+schema template to the 4 remaining
+text-parse sites. Everything else is tuning + bench + pointing side-calls at flags that exist.**
+
+---
+
+## Reconciled anchors (v7.128.2; lines drift, re-grep before editing)
+
+**completion-council.sh:** `_council_effective_min_iter()`:118 | `COUNCIL_CHECK_INTERVAL`:84 |
+`COUNCIL_STAGNATION_LIMIT`:132 | `council_evidence_gate()`:1704 | explicit-claim fast path:3640
+(block 3625-3648) | modulo gate now in helper `_council_should_check_now()`:3521-3560 (gate:3548),
+called from `council_should_stop`:3644 | `council_should_stop()`:3562
+
+**run.sh:** `detect_complexity()`:2491 | `get_rarv_tier()`:2616 | `run_code_review()`:11095 |
+`is_rate_limited()`:12835 | `check_budget_limit()`:13035 | `store_episode_trace()`:13729 |
+`save_state()`:14395 | `build_prompt()`:14633 | `run_autonomous()`:16299 | `LOKI_SESSION_MODEL`
+default:742, session-pin read:16959, case block:16963-16967 | `[CACHE_BREAKPOINT]` INERT (doc anchor
+only, no cache wiring):15143/15231/15278 | APP_CRASHED injection:14969 (python3 -c inline)
+
+**Main-loop invocation:** `run.sh:17316-17320` -> `claude "${_loki_claude_argv[@]}" -p "$prompt"
+--output-format stream-json --verbose` (argv ~17226+). Uses stream-json, not --json-schema.
+Model catalog: opus->claude-opus-4-8, sonnet->claude-sonnet-5, haiku->claude-haiku-4-5; defaults
+planning/development/fast ALL=sonnet (v7.104.0).
+
+### The 4 remaining text-parse sites (the genuine structured-output targets)
+1. **Code-review verdict** `run.sh:11044-11063` `_classify_verdict` (regex `grep -iE "VERDICT:"`
+   -> case FAIL/PASS/AMBIGUOUS, no retry) + severity greps :11075/:11090; reviewer call :10998
+   uses `--output-format text`. Parity-locked to `loki-ts/src/runner/quality_gates.ts`.
+2. **Council VOTE fallback** `completion-council.sh:645-659` (`grep -oE VOTE:`) + `:1005` (Python
+   `re.search`) - the fallback under the already-structured path; mangled VOTE silently->REJECT.
+3. **Council-v2 JSON** `council-v2.sh:337-346` (`sed -n '/^{/,/^}/p'` carves JSON from prose, else
+   hardcodes REJECT); invocation :299 (no schema).
+4. **Done-recognition** `done-recognition.sh:282-303` (`json.loads` + brace-substring fallback,
+   else `inconclusive`); call :57/:171 (no schema).
+
+---
+
+## Deliverable 1: Bench harness (BUILD/LOCK THIS FIRST - nothing ships before it)
+
+Reuse `benchmarks/bench/` (~95% built per existing plan S2a). The work is lock + reconcile +
+baseline, not a build:
+- **Lock a discriminator-derived corpus** (existing plan 2e-HARDENING #3): simple + HARD (tier-guard)
+  + MULTI-FAILURE (parallel-fix) + TOKEN-HEAVY (distillation), each with machine-checkable held-out
+  acceptance. Frozen once baselined.
+- **Reconcile iterations source** to `events.jsonl` `iteration_complete` count (canonical) with
+  session.json fallback, so `adapters/loki.py` and `speed-benchmark.sh` agree. PREREQUISITE, blocking.
+- **NEW (from live probe):** read cost/cache/iterations straight from the `--json-schema`/`--output-format
+  json` envelope (`total_cost_usd`, `cache_read_input_tokens`, `iterations[]`) instead of token-math x
+  price-table where available - more accurate, self-consistent with the CLI.
+- **Noise floor** (blocking): baseline reports SPREAD (std/min-max across trials); a change ships only
+  if its metric moves BEYOND the noise band. Effect < trial variance -> "no measurable effect", don't ship.
+- **2-spec smoke check** (the one runnable guard): one MUST-pass, one underspecified MUST-fail; assert
+  `verified_pass == [True, False]`. If the grader can't tell them apart it measures nothing.
+- **Commit the v7.128.2 baseline** (`benchmarks/results/<baseline>.json`, N real OFF-WORKTREE builds,
+  isolated source copy, cwd + LOKI_TARGET_DIR pinned to scratch) BEFORE any change.
+- **Grader stays deterministic** `success = exit==0` on held-out acceptance. NEVER council/completion-claim.
+  `validate_adapter_output()` already rejects self-judged keys - keep that invariant.
+
+**Gate rule (binding, every change):** ships iff it improves >=1 of {iterations, $/build, wall-clock}
+beyond the noise band AND does not regress verified-pass-rate on the frozen corpus vs baseline.
+
+---
+
+## Deliverable 2: Primitive-by-primitive adoption table (ranked, one per commit)
+
+Bucket key: **(a)** orchestration/flags, changeable now | **(b)** founder-gated (build_prompt
+byte-lock) | **(c)** needs off-worktree real-build validation.
+
+| # | Primitive / change | Current impl (file:line) | Native replacement | Expected win | Bucket | Parity | Rollback |
+|---|---|---|---|---|---|---|---|
+| 1 | **Structured code-review verdict** | `run.sh:11044` regex `_classify_verdict` + severity greps :11075/:11090; reviewer :10998 `--output-format text` | reviewer emits `--json-schema` (extend `voter-agents.sh`+`finding-schema.json` template); read `structured_output.verdict/severity` | Kills fragile parse + AMBIGUOUS-token bugs; zero retry. Quality-safety, not speed | (a) | safe (invocation flag, NOT build_prompt); MUST mirror in `quality_gates.ts` | keep text fallback path (like council does 3146-3154) |
+| 2 | **Structured council VOTE** (retire text fallback) | `completion-council.sh:645/1005` regex/re.search fallback | make the already-wired `--json-schema` path (3137) the only path; delete text fallback once proven | Removes silent VOTE->REJECT corruption (:2337) | (a) | safe; TS mirror `voter_agents.ts` | revert to fallback |
+| 3 | **Structured council-v2** | `council-v2.sh:337-346` sed-carved JSON | add `--json-schema` + `--output-format json` to :299 | Removes "prose around JSON"->hardcoded REJECT | (a) | safe | hardcoded-REJECT fallback stays |
+| 4 | **Structured done-recognition** | `done-recognition.sh:282-303` json.loads+brace-slice | add `--json-schema` to :57/:171 | Removes unparsable->inconclusive | (a) | safe | inconclusive fallback stays |
+| 5 | **Council interval sweep** (existing CHANGE-MAP #1) | `completion-council.sh:84` interval=5 | tune 2-3 for simple tier | fewer idle iters -> $/wall-clock | (a) | n/a | env default |
+| 6 | **Complexity->tier routing** (existing #3) | `run.sh:742` flat sonnet; case :16963 | `auto` arm: simple->haiku-enable, complex->opus-pin | $/build on simple majority | (c) | 3 readers + hard-guard | revert to `sonnet` |
+| 7 | **Native budget/effort tighten** | ALREADY plumbed `claude.sh:143-158`; side-calls (:10998, council-v2:299, done-rec:57) still bare | point side-calls at `--max-budget-usd`/`--effort` too | consistent native breaker everywhere | (a) | mirror bash<->TS flags | drop flag |
+| 8 | **Prompt caching** (existing #7, CONTINGENT) | `[CACHE_BREAKPOINT]` INERT `run.sh:15143` | wire real `cache_control` on static prefix IF CLI folds it across per-iter processes | $/build on multi-iter (cache reads visible in envelope) | (b)-adjacent | verify CLI first; may be no-op | remove marker wiring |
+| 9 | **Self-heal from logs** (existing #4) | APP_CRASHED count only `run.sh:14969`; LAST_ERROR write-only | route `tail+grep` error signature into prompt | pass-rate on crashing specs | (c) | build_prompt-adjacent -> check byte-lock | honest-degrade to today |
+
+Ranked order to execute: **1 -> 2 -> 3 -> 4** (structured-outputs cluster, all bucket-(a),
+parity-safe, mostly quality/robustness - do first, low risk) **-> 5** (interval, zero code)
+**-> 7** (side-call flag tighten) **-> 6** (tier routing, (c)) **-> 9** (self-heal, (c)) **-> 8**
+(caching, contingent, verify CLI first). Each: change, re-run corpus, apply gate rule. No bench
+move the right way = don't ship (ponytail: no no-ops).
+
+**Do NOT** touch `build_prompt()` output text (items that would: 8, 9 partially) without founder
+auth + 60-fixture regen. Structured-outputs items 1-4 do NOT touch build_prompt - confirmed
+parity-safe below.
+
+---
+
+## Deliverable 3: Parity plan
+
+**The load-bearing fact:** the 60-fixture SHA-256 lock (`loki-ts/tests/parity/build_prompt.test.ts`,
+KNOWN_FAILING empty = hard 60/60) hashes ONLY `buildPrompt()` return TEXT. CLI flags come from a
+separate surface (`claude_flags.ts` / `voter_agents.ts` / `providers.ts:244`). **So adding
+`--json-schema`/`--effort`/`--max-budget-usd` to a claude call is parity-SAFE w.r.t. the lock**, and
+also doesn't touch the 10-command CLI matrix (which never invokes a model).
+
+**The parity TRAP this arc must own** (agent-verified): a native flag added to ONE route only
+(bash `autonomy/lib/claude-flags.sh` vs TS `loki-ts/src/providers/claude_flags.ts`) would **pass all
+four parity gates** (bun-parity.yml, parity-drift.yml, local-ci matrix, build_prompt lock) while
+diverging at RUNTIME - because the matrix doesn't spawn the model. Therefore:
+- **Every native-flag change lands in BOTH `claude-flags.sh` AND `claude_flags.ts`, byte-mirrored**,
+  gated on `claudeFlagSupported()`/`loki_claude_flag_supported` for old-CLI degrade.
+- **Proven by the flag-parity unit tests** (`loki-ts/tests/runner/providers.test.ts`,
+  `tests/test-bash-bun-parity.sh` run at `local-ci.sh:390`), NOT the CLI matrix. Add a case per new flag.
+- Structured-output items 1-4: mirror the bash change (voter-agents/council-v2/done-rec/quality-gates)
+  in the corresponding TS (`council/voter_agents.ts`, `runner/quality_gates.ts`).
+- **build_prompt-touching items (8, 9)**: founder-gated. Regenerate all 60 fixtures via `run-bash.sh`
+  (`for i in $(seq 1 60); do bash run-bash.sh fixture-$i; done`), regenerate `index.json`, keep bash<->TS
+  60/60 in the SAME PR. Watch the fixtures 27/45 alphabetical-readdir determinism guard.
+- **Doctor normalizers are TRIPLICATED** (`bun-parity.yml:127-184`, `parity-drift.yml:83-135`,
+  `local-ci.sh:812-860`) with subtle diffs (JSON floor-vs-delete, counts kept-vs-blanked). If any
+  primitive changes doctor output, edit ALL THREE in sync.
+
+Every commit proven on BOTH routes (`bin/loki` + `LOKI_LEGACY_BASH=1 bin/loki`).
+
+---
+
+## Deliverable 4: Gate plan
+
+- **Trust-core = 3-reviewer council** (2 Opus + 1 Sonnet, unanimous APPROVE, reviewers RUN tests).
+  Any CONCERN/REJECT -> read source, fix, RE-RUN whole council. Loop to 3/3. Never "2-of-3".
+- **`bash scripts/local-ci.sh` green before EVERY push** (Step 0). It mirrors every workflow:
+  bash -n + shellcheck, pytest, `bun typecheck` + `bun test` (the 60-fixture lock runs here),
+  CLI dual-route (`test-cli-commands.sh` Bun + LEGACY_BASH), `test-bash-bun-parity.sh`, the local
+  bun-parity matrix, npm-pack contents (>=6 load-bearing files), SBOM, no-emoji, no-`git add -A`.
+- **Extraction-test harness for bash fn changes** (`feedback-function-extraction-test-harness`):
+  extract the changed fn AND every helper it calls (grep `sed -n '/^<fn>() {/'` tests); `set +u`
+  inside the eval subshell; prove runtime-vs-test before "fixing" a red test (fix the TEST if runtime
+  is right, never patch correct code).
+- **RARV-C changes proven with hermetic Bun integration tests** (stub judge, `LOKI_OVERRIDE_REAL_JUDGE=0`,
+  mkdtemp scratch, no token cost) - pattern in `loki-ts/tests/integration/override_on_block.test.ts`.
+- **Never run an engine build from the worktree** (`feedback-never-run-engine-build`): all real builds
+  from isolated source copy, cwd + LOKI_TARGET_DIR pinned to scratch.
+
+---
+
+## Deliverable 5: Release plan (v8.0.0, MAJOR)
+
+- **14 version locations** (all verified at 7.128.2, zero drift): VERSION:1, package.json:4,
+  SKILL.md:6+411, Dockerfile:9/14, Dockerfile.sandbox:102/103, plugins/.../plugin.json:5, CLAUDE.md:306,
+  dashboard/__init__.py:10, mcp/__init__.py:60, CHANGELOG.md:8, docs/INSTALLATION.md:5(+399 docker tag),
+  wiki/Home.md:106, wiki/_Sidebar.md:46, wiki/API-Reference.md:69.
+- **MAJOR bump also touches docker-tag group** (README.md ~81/~380, docs/INSTALLATION.md 7+ tags,
+  docker-compose.yml:1).
+- **Do NOT touch** (independently versioned, would break if "fixed"): `sdk/python/pyproject.toml`
+  (auto-synced by release.yml:352 at publish), `sdk/typescript/package.json` (5.55.0),
+  `loki-ts/package.json` (0.1.0-alpha.1), `vscode-extension/package.json` (deprecated).
+- **FIX in v8 - release-notes bug** (`release.yml:179/231`): awk expects bracketed `## [VERSION]` but
+  CHANGELOG uses unbracketed `## vVERSION`, so release notes have silently been generic. Fix the awk or
+  the header format (one PR, verify the extracted body is non-empty).
+- **Dashboard frontend rebuilt** (`cd dashboard-ui && npm ci && npm run build:all`) - writes both
+  `dashboard-ui/dist/` and `dashboard/static/`.
+- **Pre-publish validation** (CLAUDE.md 3a): `npm pack --dry-run` contains web-app/dist + dashboard/static;
+  fresh global install serves web app + API.
+- **Per-job release verification**: `gh run view <id> --json jobs` per channel (npm/Docker/Homebrew/Release),
+  not just "workflow green".
+- **Post-release smoke from SHIPPED artifacts on BOTH routes**: `npm pack loki-mode@8.0.0` + `bun run bin/loki
+  version` and `LOKI_LEGACY_BASH=1 ... version`; `docker run --rm asklokesh/loki-mode:8.0.0 doctor --json`;
+  WebFetch brew formula version+sha.
+- **Cleanup after every local-ci/validation**: `lsof -ti:57374 | xargs kill -9; rm -rf /tmp/loki-* /tmp/test-* /tmp/package /tmp/*.tgz`.
+
+---
+
+## Do-NOT list (binding)
+
+1. Do NOT replace the 3-reviewer council with a single-LLM outcome-grader. Structured-outputs changes
+   the OUTPUT FORMAT (text->JSON), NOT the 3-judge architecture. That's the moat.
+2. Do NOT add an LLM judge to the bench grader (deterministic exit==0 only; `validate_adapter_output`
+   rejects self-judged keys).
+3. Do NOT trust council APPROVE / completion-claim as the bench pass signal (fake-green failure mode).
+4. Do NOT touch `build_prompt()` output text without founder auth + 60-fixture regen + 60/60 bash<->TS.
+5. Do NOT change corpus/grader/price-table across a before/after pair.
+6. Do NOT run a real engine build from the worktree.
+7. Do NOT add a native flag to one route only (silent runtime divergence past all parity gates).
+8. Do NOT ship a change that doesn't move the bench the right way.
+9. Do NOT rebuild what's already adopted (--effort/--max-budget-usd plumbing, council --json-schema path).
+
+---
+
+## FOUNDER SCOPE DECISIONS (2026-07-13, locked)
+
+- **SCOPE = FULL ARC** including founder-gated items 8 (caching) and 9 (self-heal-from-logs).
+  This constitutes explicit authorization to unlock `build_prompt()`'s 60-fixture byte-lock WHEN
+  those items come up - executed per Deliverable 3 (regenerate all 60 fixtures via `run-bash.sh`,
+  keep bash<->TS 60/60 in the same PR, full council + local-ci). Founder-gated items still run LAST,
+  after all bucket-(a) structured-output wins are banked and bench-measured. Caching (8) still
+  requires the CLI-mechanics verification (does the CLI fold cache_control across per-iteration
+  processes?) BEFORE committing - if it's a no-op, report that and drop it, don't ship a no-op.
+- **BASELINE = 3-SPEC SMOKE FIRST.** Prove the full pipeline (baseline -> one change -> measure ->
+  gate rule) on a tiny 3-spec corpus to validate the harness machinery cheaply, THEN build the real
+  discriminator-derived corpus (simple+hard+multi-failure+token-heavy) and run the full v7.128.2
+  baseline. Catches harness bugs before the big real-dollar run.
+- **Honesty pre-commit stands:** most iteration wins are already shipped; expect single-digit-% to
+  maybe-2x from tuning, NOT 100x (the real 100x is the already-scoped k8s INFRA work, not this arc).
+  Report the true number even if unimpressive.
+
+## Consolidation + sequencing
+
+1. Create branch `feature/rarv-c-100x-primitives`. Build harness, run 3-SPEC SMOKE to validate the
+   pipeline, then commit the full v7.128.2 baseline (Deliverable 1) before any change.
+2. Write `docs/RARV-C-100X-PLAN.md` = this plan (supersedes/links the two prior v7.121.5 docs; keep
+   them as history, note they're superseded).
+3. Execute the adoption table in ranked order, one primitive per commit, bench + full gate after each.
+4. Founder-gated items (8 caching, 9 self-heal build_prompt half) LAST, only after (a)-items banked and
+   explicit unlock.
+5. Release v8.0.0 per Deliverable 5 once the bench shows the aggregate win (or honestly report the real
+   delta if single-digit - the plan pre-commits to reporting the true number, not dressing it up).
+
+## Verification (how to test end-to-end)
+- Bench: `bash benchmarks/bench/run.sh run <spec> --trials 3` from isolated scratch; read
+  iterations/cost/duration from result JSON; grader `exit==0`. 2-spec smoke asserts [pass, fail].
+- Structured-outputs: hermetic Bun integration test with stub judge asserts JSON verdict parsed,
+  no text-regex path hit; + extraction test for the bash side.
+- Parity: `bash scripts/local-ci.sh` green (runs 60-fixture lock + dual-route CLI + flag-parity tests).
+- Per commit: full 3-reviewer council + local-ci, both routes.

package/docs/RARV-C-CHANGE-MAP.md

@@ -1,5 +1,10 @@
 # RARV-C Efficiency Change Map (apply-and-measure, from lever investigation)
 
+> SUPERSEDED by `docs/RARV-C-100X-PLAN.md` (v8.0.0 arc, 2026-07-13). Kept as history.
+> Anchors here are grounded to v7.121.5 and have DRIFTED; use the 100X plan for current
+> file:line. Note: budget/effort (#7) and council --json-schema were adopted AFTER this doc.
+
+
 Both checks resolve cleanly:
 
 **Check 1 (env propagation): CONFIRMED SAFE.** `_base.py:113` does `full_env = dict(os.environ)` then passes it as `env=full_env` to subprocess. The loki adapter (`loki.py:120`) uses `run_env`. So env-prefixing the bench invocation propagates the knob into the loki subprocess, where completion-council.sh:84 reads it at source time. Every `KNOB=x bench run` command in the plan is a real measurement, not a no-op.

package/docs/RARV-C-LOOP-EFFICIENCY-PLAN.md

@@ -1,5 +1,10 @@
 # RARV-C Loop-Efficiency Upgrade Plan (ultracode phase)
 
+> SUPERSEDED by `docs/RARV-C-100X-PLAN.md` (v8.0.0 arc, 2026-07-13). Kept as history.
+> Anchors here are grounded to v7.121.5 and have DRIFTED; use the 100X plan for current
+> file:line and for the native-primitives-already-adopted findings.
+
+
 Architect: synthesis of the six cookbook pattern sets against the current
 Loki RARV-C loop. This is a PLAN, not code. Every proposed change carries a
 constraint bucket and a bench-gate. No benchmark numbers are asserted here --

package/loki-ts/data/code-review-schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://loki-mode.dev/schemas/code-review.json",
+  "title": "Loki Code-Review Verdict",
+  "description": "Structured output contract for the 8-gate code-review reviewer (main + Devils-Advocate). Claude Code emits this when invoked with --json-schema (INLINE content, not a path) --output-format json. A python3/TS adapter re-materializes it into the legacy 'VERDICT: X\\nFINDINGS:\\n- [severity] description' text so _classify_verdict, _severity_is_blocking, _count_nonblocking_findings, the mergeability score, the DA arm, and aggregate.json stay byte-identical. verdict is the sole gating token; findings[].severity feeds blocking (Critical/High) and mergeability (Medium/Low) weighting. NOTE: JSON Schema cannot express the cross-field rule 'a Critical/High finding requires verdict FAIL'; the re-materializer enforces it (force-FAIL on any Critical/High finding) so a self-contradictory PASS+Critical can never be waved through as non-blocking.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["verdict", "findings"],
+  "properties": {
+    "verdict": {
+      "type": "string",
+      "enum": ["PASS", "FAIL"],
+      "description": "PASS if no blocking issue; FAIL if a real issue was found. A FAIL with a Critical or High finding blocks the merge; a FAIL with only Medium/Low is a non-blocking dissent. If any finding is Critical or High you MUST set verdict to FAIL."
+    },
+    "findings": {
+      "type": "array",
+      "minItems": 0,
+      "description": "Zero or more issues. Empty array means clean (equivalent to the legacy '- None' bullet).",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["severity", "description"],
+        "properties": {
+          "severity": {
+            "type": "string",
+            "enum": ["Critical", "High", "Medium", "Low"],
+            "description": "Critical/High are blocking; Medium/Low are advisory and feed the mergeability score."
+          },
+          "description": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 2000,
+            "description": "One-line issue description, ideally ending with (file:line)."
+          }
+        }
+      }
+    }
+  }
+}

package/loki-ts/data/council-v2-schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://loki-mode.dev/schemas/council-v2.json",
+  "title": "Loki Council-v2 Reviewer Verdict",
+  "description": "Structured output contract for a council-v2 reviewer (requirements/test/quality/devils-advocate/general). Claude Code emits this when invoked with --json-schema (INLINE content, not a path) --output-format json. The council-v2 dispatch reads structured_output directly; a sed-carve of prose JSON remains the fail-closed fallback. verdict is the gating token; any parse miss defaults to REJECT (the safe direction).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["verdict", "reasoning", "issues"],
+  "properties": {
+    "verdict": {
+      "type": "string",
+      "enum": ["APPROVE", "REJECT"],
+      "description": "APPROVE if the evidence satisfies the requirements for this reviewer's lens; REJECT otherwise."
+    },
+    "reasoning": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 4000,
+      "description": "Short justification for the verdict."
+    },
+    "issues": {
+      "type": "array",
+      "minItems": 0,
+      "description": "Zero or more issues found. Empty array is allowed on APPROVE.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["severity", "description"],
+        "properties": {
+          "severity": {
+            "type": "string",
+            "enum": ["CRITICAL", "HIGH", "MEDIUM", "LOW"],
+            "description": "Issue severity."
+          },
+          "description": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 2000,
+            "description": "One-line issue description."
+          }
+        }
+      }
+    }
+  }
+}

package/loki-ts/data/done-recognition-schema.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://loki-mode.dev/schemas/done-recognition.json",
+  "title": "Loki Done-Recognition Verdict",
+  "description": "Structured output contract for the done-recognition gate (is a reused PRD already satisfied by the current codebase?). Claude Code emits this when invoked with --json-schema (INLINE content, not a path) --output-format json. The gate DEFENSIVELY re-derives the verdict from requirements[].status, never trusting the top-line verdict, so a valid requirements array is the load-bearing part. Any parse miss falls back to the existing json.loads/brace-slice path, which defaults to inconclusive (the safe direction).",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["verdict", "summary", "requirements"],
+  "properties": {
+    "verdict": {
+      "type": "string",
+      "enum": ["done", "incomplete", "inconclusive"],
+      "description": "Top-line claim. done ONLY when ALL requirements are met AND fresh tests are green; incomplete when any requirement is unmet; inconclusive when ground truth cannot be established. The gate re-derives this from requirements[].status regardless."
+    },
+    "summary": {
+      "type": "string",
+      "maxLength": 2000,
+      "description": "One plain sentence for the user."
+    },
+    "tests": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["passed", "total", "green"],
+      "properties": {
+        "passed": { "type": "integer", "minimum": 0 },
+        "total": { "type": "integer", "minimum": 0 },
+        "green": { "type": "boolean" }
+      }
+    },
+    "requirements": {
+      "type": "array",
+      "minItems": 0,
+      "description": "One entry per PRD requirement, with its satisfaction status. The gate re-derives the verdict from these statuses.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "status"],
+        "properties": {
+          "id": { "type": "string", "maxLength": 256 },
+          "title": { "type": "string", "minLength": 1, "maxLength": 512 },
+          "status": {
+            "type": "string",
+            "enum": ["met", "unmet", "uncertain"],
+            "description": "met = proven satisfied; unmet = not implemented; uncertain = cannot establish."
+          },
+          "evidence": { "type": "string", "maxLength": 1024 }
+        }
+      }
+    }
+  }
+}

package/loki-ts/dist/loki.js

@@ -1,5 +1,5 @@
 // @bun
-var q8=Object.defineProperty;var J8=($)=>$;function V8($,Q){this[$]=J8.bind(null,Q)}var b=($,Q)=>{for(var Z in Q)q8($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:V8.bind(Q,Z)})};var P=($,Q)=>()=>($&&(Q=$($=0)),Q);var J$=import.meta.require;var m1={};b(m1,{lokiDir:()=>j,homeLokiDir:()=>T$,findRepoRootForVersion:()=>$1,REPO_ROOT:()=>h});import{resolve as t,dirname as e$}from"path";import{fileURLToPath as W8}from"url";import{existsSync as N$}from"fs";import{homedir as H8}from"os";function G8(){let $=v1;for(let Q=0;Q<6;Q++){if(N$(t($,"VERSION"))&&N$(t($,"autonomy/run.sh")))return $;let Z=e$($);if(Z===$)break;$=Z}return t(v1,"..","..","..")}function $1($){let Q=$;for(let Z=0;Z<6;Z++){if(N$(t(Q,"VERSION"))&&N$(t(Q,"autonomy/run.sh")))return Q;let z=e$(Q);if(z===Q)break;Q=z}return t($,"..","..","..")}function j(){return process.env.LOKI_DIR??t(process.cwd(),".loki")}function T$(){return t(H8(),".loki")}var v1,h;var C=P(()=>{v1=e$(W8(import.meta.url));h=G8()});import{readFileSync as U8}from"fs";import{resolve as Y8,dirname as B8}from"path";import{fileURLToPath as M8}from"url";function S$(){if(Q$!==null)return Q$;let $="7.128.2";if(typeof $==="string"&&$.length>0)return Q$=$,Q$;try{let Q=B8(M8(import.meta.url)),Z=$1(Q);Q$=U8(Y8(Z,"VERSION"),"utf-8").trim()}catch{Q$="unknown"}return Q$}var Q$=null;var Q1=P(()=>{C()});var p1={};b(p1,{runOrThrow:()=>S8,run:()=>R,readStreamCapped:()=>c1,commandVersion:()=>C8,commandExists:()=>u,ShellError:()=>Z1,MAX_STDOUT_BYTES:()=>u1});async function c1($,Q=u1){let Z=$.getReader(),z=new TextDecoder,X="",q=0;try{while(q<Q){let{done:K,value:W}=await Z.read();if(K)break;if(!W)continue;if(q+=W.byteLength,q>Q){let V=W.byteLength-(q-Q);X+=z.decode(W.subarray(0,V),{stream:!0});break}X+=z.decode(W,{stream:!0})}X+=z.decode()}finally{try{await Z.cancel()}catch{}Z.releaseLock()}return X}async function R($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,X;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}X=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[q,K,W]=await Promise.all([c1(Z.stdout),new Response(Z.stderr).text(),Z.exited]);return{stdout:q,stderr:K,exitCode:W}}finally{if(z)clearTimeout(z);if(X)clearTimeout(X)}}async function S8($,Q={}){let Z=await R($,Q);if(Z.exitCode!==0)throw new Z1(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function u($){let Q=D8($),Z=await R(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function D8($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function C8($,Q="--version"){if(!await u($))return null;let z=await R([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var u1=16777216,Z1;var o=P(()=>{Z1=class Z1 extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function r($){return b8?"":$}var b8,M,S,_,tZ,L,k,y,J;var p=P(()=>{b8=(process.env.NO_COLOR??"").length>0;M=r("\x1B[0;31m"),S=r("\x1B[0;32m"),_=r("\x1B[1;33m"),tZ=r("\x1B[0;34m"),L=r("\x1B[0;36m"),k=r("\x1B[1m"),y=r("\x1B[2m"),J=r("\x1B[0m")});import{existsSync as l8}from"fs";async function Z$(){if(A$!==void 0)return A$;let $="/opt/homebrew/bin/python3.12";if(l8($))return A$=$,$;let Q=await u("python3.12");if(Q)return A$=Q,Q;let Z=await u("python3");return A$=Z,Z}async function z$($,Q={}){let Z=await Z$();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return R([Z,"-c",$],Q)}var A$;var V$=P(()=>{o()});var V0={};b(V0,{runStatus:()=>U3});import{existsSync as v,readFileSync as H$,readdirSync as $0,statSync as Q0}from"fs";import{resolve as D,basename as z3}from"path";import{homedir as X3}from"os";function Z0($){let Q=Math.trunc($);if(Q>=1e6)return`${(Math.trunc(Q/1e6*10)/10).toFixed(1)}M`;if(Q>=1000)return`${(Math.trunc(Q/1000*10)/10).toFixed(1)}K`;return String(Q)}function z0($,Q,Z){if(Q===0)return null;let z=Math.trunc($*100/Q),X=Math.trunc($*C$/Q);if(X>C$)X=C$;let q=C$-X,K=S;if(z>=80)K=M;else if(z>=50)K=_;let W="=".repeat(Math.max(0,X))+" ".repeat(Math.max(0,q)),V=Z0($),H=Z0(Q);return`  ${k}${Z}${J} ${K}[${W}]${J} ${z}% (${V} / ${H})`}async function q3(){if(await u("jq"))return!0;return process.stdout.write(`${M}Error: jq is required but not installed.${J}
+var q8=Object.defineProperty;var J8=($)=>$;function V8($,Q){this[$]=J8.bind(null,Q)}var b=($,Q)=>{for(var Z in Q)q8($,Z,{get:Q[Z],enumerable:!0,configurable:!0,set:V8.bind(Q,Z)})};var P=($,Q)=>()=>($&&(Q=$($=0)),Q);var J$=import.meta.require;var m1={};b(m1,{lokiDir:()=>j,homeLokiDir:()=>T$,findRepoRootForVersion:()=>$1,REPO_ROOT:()=>h});import{resolve as t,dirname as e$}from"path";import{fileURLToPath as W8}from"url";import{existsSync as N$}from"fs";import{homedir as H8}from"os";function G8(){let $=v1;for(let Q=0;Q<6;Q++){if(N$(t($,"VERSION"))&&N$(t($,"autonomy/run.sh")))return $;let Z=e$($);if(Z===$)break;$=Z}return t(v1,"..","..","..")}function $1($){let Q=$;for(let Z=0;Z<6;Z++){if(N$(t(Q,"VERSION"))&&N$(t(Q,"autonomy/run.sh")))return Q;let z=e$(Q);if(z===Q)break;Q=z}return t($,"..","..","..")}function j(){return process.env.LOKI_DIR??t(process.cwd(),".loki")}function T$(){return t(H8(),".loki")}var v1,h;var C=P(()=>{v1=e$(W8(import.meta.url));h=G8()});import{readFileSync as U8}from"fs";import{resolve as Y8,dirname as B8}from"path";import{fileURLToPath as M8}from"url";function S$(){if(Q$!==null)return Q$;let $="7.129.0";if(typeof $==="string"&&$.length>0)return Q$=$,Q$;try{let Q=B8(M8(import.meta.url)),Z=$1(Q);Q$=U8(Y8(Z,"VERSION"),"utf-8").trim()}catch{Q$="unknown"}return Q$}var Q$=null;var Q1=P(()=>{C()});var p1={};b(p1,{runOrThrow:()=>S8,run:()=>R,readStreamCapped:()=>c1,commandVersion:()=>C8,commandExists:()=>u,ShellError:()=>Z1,MAX_STDOUT_BYTES:()=>u1});async function c1($,Q=u1){let Z=$.getReader(),z=new TextDecoder,X="",q=0;try{while(q<Q){let{done:K,value:W}=await Z.read();if(K)break;if(!W)continue;if(q+=W.byteLength,q>Q){let V=W.byteLength-(q-Q);X+=z.decode(W.subarray(0,V),{stream:!0});break}X+=z.decode(W,{stream:!0})}X+=z.decode()}finally{try{await Z.cancel()}catch{}Z.releaseLock()}return X}async function R($,Q={}){let Z=Bun.spawn({cmd:[...$],stdout:"pipe",stderr:"pipe",env:Q.env?{...process.env,...Q.env}:process.env,cwd:Q.cwd}),z,X;if(Q.timeoutMs&&Q.timeoutMs>0)z=setTimeout(()=>{try{Z.kill("SIGTERM")}catch{}X=setTimeout(()=>{try{Z.kill("SIGKILL")}catch{}},2000)},Q.timeoutMs);try{let[q,K,W]=await Promise.all([c1(Z.stdout),new Response(Z.stderr).text(),Z.exited]);return{stdout:q,stderr:K,exitCode:W}}finally{if(z)clearTimeout(z);if(X)clearTimeout(X)}}async function S8($,Q={}){let Z=await R($,Q);if(Z.exitCode!==0)throw new Z1(`command failed (${Z.exitCode}): ${$.join(" ")}`,Z.exitCode,Z.stdout,Z.stderr);return Z}async function u($){let Q=D8($),Z=await R(["sh","-c",`command -v ${Q}`],{timeoutMs:5000});if(Z.exitCode===0)return Z.stdout.trim()||null;return null}function D8($){if(!/^[A-Za-z0-9._/-]+$/.test($))throw Error(`refused to shell-escape suspect token: ${$}`);return $}async function C8($,Q="--version"){if(!await u($))return null;let z=await R([$,Q],{timeoutMs:5000});if(z.exitCode!==0)return null;return((z.stdout||z.stderr).split(/\r?\n/)[0]?.trim()??"")||null}var u1=16777216,Z1;var o=P(()=>{Z1=class Z1 extends Error{message;exitCode;stdout;stderr;constructor($,Q,Z,z){super($);this.message=$;this.exitCode=Q;this.stdout=Z;this.stderr=z;this.name="ShellError"}}});function r($){return b8?"":$}var b8,M,S,_,tZ,L,k,y,J;var p=P(()=>{b8=(process.env.NO_COLOR??"").length>0;M=r("\x1B[0;31m"),S=r("\x1B[0;32m"),_=r("\x1B[1;33m"),tZ=r("\x1B[0;34m"),L=r("\x1B[0;36m"),k=r("\x1B[1m"),y=r("\x1B[2m"),J=r("\x1B[0m")});import{existsSync as l8}from"fs";async function Z$(){if(A$!==void 0)return A$;let $="/opt/homebrew/bin/python3.12";if(l8($))return A$=$,$;let Q=await u("python3.12");if(Q)return A$=Q,Q;let Z=await u("python3");return A$=Z,Z}async function z$($,Q={}){let Z=await Z$();if(!Z)return{stdout:"",stderr:"python3 not found",exitCode:127};return R([Z,"-c",$],Q)}var A$;var V$=P(()=>{o()});var V0={};b(V0,{runStatus:()=>U3});import{existsSync as v,readFileSync as H$,readdirSync as $0,statSync as Q0}from"fs";import{resolve as D,basename as z3}from"path";import{homedir as X3}from"os";function Z0($){let Q=Math.trunc($);if(Q>=1e6)return`${(Math.trunc(Q/1e6*10)/10).toFixed(1)}M`;if(Q>=1000)return`${(Math.trunc(Q/1000*10)/10).toFixed(1)}K`;return String(Q)}function z0($,Q,Z){if(Q===0)return null;let z=Math.trunc($*100/Q),X=Math.trunc($*C$/Q);if(X>C$)X=C$;let q=C$-X,K=S;if(z>=80)K=M;else if(z>=50)K=_;let W="=".repeat(Math.max(0,X))+" ".repeat(Math.max(0,q)),V=Z0($),H=Z0(Q);return`  ${k}${Z}${J} ${K}[${W}]${J} ${z}% (${V} / ${H})`}async function q3(){if(await u("jq"))return!0;return process.stdout.write(`${M}Error: jq is required but not installed.${J}
 `),process.stdout.write(`Install with:
 `),process.stdout.write(`  brew install jq    (macOS)
 `),process.stdout.write(`  apt install jq     (Debian/Ubuntu)
@@ -814,4 +814,4 @@ Set LOKI_LEGACY_BASH=1 to force the bash CLI for every command.
 `),2}default:return process.stderr.write(`Unknown command: ${Q}
 `),process.stderr.write(K8),2}}e1();process.on("SIGINT",()=>process.exit(130));process.on("SIGTERM",()=>process.exit(143));var SZ=await NZ(Bun.argv.slice(2));process.exit(SZ);
 
-//# debugId=3642C2645E1F762E64756E2164756E21
+//# debugId=4C57B2F2D01C30E264756E2164756E21

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.128.2'
+__version__ = '7.129.0'

package/package.json

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