loki-mode 7.118.0 → 7.120.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.118.0
+# Loki Mode v7.120.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.118.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.120.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.118.0
+7.120.0

package/autonomy/lib/proof-generator.py

@@ -341,7 +341,20 @@ def _collect_build(loki_dir):
     out["exit_code"] = _to_int(ec, None) if ec is not None else None
     dur = raw.get("duration_sec")
     out["duration_sec"] = _to_float(dur, None) if dur is not None else None
-    if not ran:
+    # HONEST APPLICABILITY (build has no writer historically -> facts.build was
+    # permanently "not_run" for every project, counting a CLI with no build step
+    # as a gap and dragging the headline to WITH GAPS). The writer now records a
+    # POSITIVE applicability signal: applicable:false means "this stack genuinely
+    # has no build phase" (a CLI, a plain script). That is N/A, not a skipped
+    # gap, so it must NOT be a degraded item. CRITICAL anti-fake-green rule:
+    # not_applicable ONLY from an EXPLICIT applicable:false in the file. An absent
+    # file or a missing/true applicable flag stays not_run (an honest gap) -- an
+    # un-built project must never flip green just because nobody wrote the file.
+    applicable = raw.get("applicable", True)
+    out["applicable"] = bool(applicable)
+    if applicable is False:
+        out["status"] = "not_applicable"
+    elif not ran:
         out["status"] = "not_run"
     elif out["exit_code"] == 0:
         out["status"] = "verified"

package/autonomy/run.sh

@@ -8354,6 +8354,163 @@ COMPOUND_SCRIPT
 # Results stored in .loki/quality/static-analysis.json
 # ============================================================================
 
+# ---------------------------------------------------------------------------
+# enforce_build_check -- run the stack's build (if it has one) and record an
+# HONEST build fact for the Evidence Receipt (#47). Historically nothing wrote
+# .loki/quality/build-results.json, so facts.build was PERMANENTLY "not_run" for
+# every project -- a CLI with no build step read identically to a skipped real
+# build, and both dragged the receipt to "WITH GAPS". This is the missing writer.
+#
+# The distinction the receipt needs (and the founder demanded, no fabrication) is
+# THREE-WAY, not two (a council review caught the two-way version laundering
+# "unrecognized build system" into a fake N/A):
+#   - a build command WE RUN exists (npm "build" / go / cargo) -> RUN it, record
+#     ran/exit_code (verified on 0, failed otherwise -- a real gap kept honest).
+#   - a build system EXISTS but we do not auto-run it (Make/Maven/Gradle/.NET, a
+#     non-"build" npm script, a pyproject build-system) -> not_run (an HONEST GAP,
+#     matching verify.sh:291's "skipped"). NEVER N/A -- a real, un-run build must
+#     never read VERIFIED.
+#   - genuinely NO build phase at all (a plain CLI/script) -> applicable:false
+#     (status not_applicable). A POSITIVE "no build phase" determination, NOT an
+#     absent file -- proof-generator maps applicable:false -> N/A (not a gap) but a
+#     MISSING file or an unrecognized-real build stays not_run. One vocabulary, no
+#     fake-green. Pinned by tests/test-build-check-applicability.sh.
+# ---------------------------------------------------------------------------
+enforce_build_check() {
+    local tree="${TARGET_DIR:-.}"
+    local loki_dir="$tree/.loki"
+    local quality_dir="$loki_dir/quality"
+    mkdir -p "$quality_dir"
+    local out_file="$quality_dir/build-results.json"
+    local timeout_s="${LOKI_GATE_TIMEOUT:-300}"
+    local ts; ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+    # THREE-WAY classification (detection is always cheap). The anti-fake-green line
+    # (council-caught): N/A is ONLY for a POSITIVE "this stack has no build phase"
+    # determination. An unrecognized-but-real build system (Make, Maven, Gradle,
+    # .NET, a non-"build" npm build script) must stay an HONEST GAP (not_run), NOT
+    # be laundered into N/A -- otherwise a real, un-run build reads VERIFIED. This
+    # mirrors verify.sh:291, which records the same fall-through as a "skipped" gap.
+    #   runnable   -> a build command WE run (npm build / go / cargo) -> verified/failed
+    #   present    -> a build system EXISTS but we don't auto-run it   -> not_run (GAP)
+    #   none       -> positively no build phase at all                 -> not_applicable (N/A)
+    local cmd="" ran="false" applicable="false" exit_code="null" status="not_run"
+    local build_class="present"
+
+    # INVERTED classification (three council rounds each found a fake-green hole in
+    # an allowlist of build systems -> the allowlist is structurally leaky). The
+    # two error directions are NOT equal: a REAL build read as N/A -> VERIFIED is
+    # DISHONEST over-claim (the cardinal fake-green sin); a no-build CLI read as a
+    # not_run gap is an HONEST under-claim (merely the founder's original UX nit).
+    # So not_run is the SAFE CATCH-ALL and N/A requires a POSITIVE proof-of-no-build.
+    # A forgotten stack (Bazel, meson, autotools, Zig, Nix...) now falls to not_run
+    # (honest), never to fake N/A -- fixing the whole CLASS, not each instance.
+    #   1. runnable: a build command WE run -> verified/failed
+    #   2. none:     POSITIVE proof of no build phase -> not_applicable (N/A)
+    #   3. else:     not_run (honest gap) -- the default, covers every unknown stack
+
+    if [ -f "$tree/package.json" ] && grep -q '"build"[[:space:]]*:' "$tree/package.json" 2>/dev/null; then
+        cmd="npm run build"; applicable="true"; build_class="runnable"
+    elif [ -f "$tree/go.mod" ] && command -v go >/dev/null 2>&1; then
+        cmd="go build ./..."; applicable="true"; build_class="runnable"
+    elif [ -f "$tree/Cargo.toml" ] && command -v cargo >/dev/null 2>&1; then
+        cmd="cargo build"; applicable="true"; build_class="runnable"
+    else
+        # POSITIVE proof-of-no-build (the ONLY path to N/A). Two narrow cases, and
+        # anything short of a clear determination stays not_run:
+        #   (a) a package.json whose scripts exist but include NO build-ish script
+        #       AND there is no foreign build manifest -> a JS CLI/lib with no build.
+        #   (b) NO build manifest of ANY known kind at all -> a plain script dir.
+        # The build-ish regex is used as an EXCLUSION so a build hidden under a
+        # non-"build" script name (compile/dist/...) does NOT misfire N/A.
+        local has_foreign_manifest="false"
+        if [ -f "$tree/go.mod" ] || [ -f "$tree/Cargo.toml" ] \
+           || [ -f "$tree/Makefile" ] || [ -f "$tree/makefile" ] || [ -f "$tree/GNUmakefile" ] \
+           || [ -f "$tree/Makefile.in" ] || [ -f "$tree/configure" ] || [ -f "$tree/configure.ac" ] || [ -f "$tree/configure.in" ] \
+           || [ -f "$tree/CMakeLists.txt" ] || [ -f "$tree/meson.build" ] \
+           || [ -f "$tree/pom.xml" ] || [ -f "$tree/build.xml" ] \
+           || [ -f "$tree/build.gradle" ] || [ -f "$tree/build.gradle.kts" ] \
+           || [ -f "$tree/settings.gradle" ] || [ -f "$tree/settings.gradle.kts" ] || [ -f "$tree/gradlew" ] \
+           || [ -f "$tree/build.sbt" ] \
+           || [ -f "$tree/WORKSPACE" ] || [ -f "$tree/WORKSPACE.bazel" ] || [ -f "$tree/MODULE.bazel" ] \
+           || [ -f "$tree/setup.py" ] || [ -f "$tree/pyproject.toml" ] \
+           || compgen -G "$tree/*.csproj" >/dev/null 2>&1 \
+           || compgen -G "$tree/*.sln" >/dev/null 2>&1 \
+           || compgen -G "$tree/*.fsproj" >/dev/null 2>&1; then
+            has_foreign_manifest="true"
+        fi
+        # N/A fires on POSITIVE proof-of-no-build, which we can only assert for a
+        # package.json project: it EXISTS and its scripts are build-ish-free and no
+        # foreign manifest / build-tool devDep is present -> a JS CLI/lib that
+        # genuinely has no build step (the founder's invoice case). CRITICAL (the
+        # council's convergence line): a project with NO package.json is "I don't
+        # recognize a build here" = IGNORANCE, not proof-of-no-build. Ignorance must
+        # map to not_run (honest gap), NEVER N/A -- else Zig/autotools/bare-C/meson/
+        # bazel/anything-unborn silently reads VERIFIED. This makes the ENTIRE
+        # no-package.json universe honest by CONSTRUCTION (list-free), which is why
+        # this converges where four rounds of adding-to-a-list could not.
+        if [ "$has_foreign_manifest" = "false" ] && [ -f "$tree/package.json" ]; then
+            local has_build_devdep="false"
+            # A build TOOL as a (dev)dependency means a build exists even if it runs
+            # under a non-"build" script name -> stay not_run, do not claim N/A.
+            if grep -qE '"(vite|webpack|rollup|esbuild|parcel|typescript|tsc|@swc/core|turbopack|rspack|tsup|microbundle)"[[:space:]]*:' "$tree/package.json" 2>/dev/null; then
+                has_build_devdep="true"
+            fi
+            if [ "$has_build_devdep" = "false" ] \
+               && ! grep -qE '"(build|compile|dist|bundle|webpack|vite|tsc|rollup|esbuild|prepare|prepack)"[[:space:]]*:' "$tree/package.json" 2>/dev/null; then
+                applicable="false"; build_class="none"
+            fi
+            # else: a build-ish script or a build-tool devDep we don't auto-run ->
+            # stays not_run (an honest gap). Known bounded edge: a polyglot repo with
+            # a package.json (no build) co-present with an UNLISTED foreign build
+            # manifest could read N/A; not common and not list-free-fixable, so it is
+            # a documented CONCERN, not a blocker.
+        fi
+        # No package.json (foreign or not) -> build_class stays "present" -> not_run.
+        # has_foreign_manifest=true -> also not_run. Only the narrow package.json-
+        # no-build case above reaches N/A.
+    fi
+
+    if [ "$build_class" = "present" ]; then
+        # A build phase exists but we did not run it -> honest not_run gap. applicable
+        # stays true (a build IS applicable), status not_run (we did not verify it).
+        applicable="true"; ran="false"; status="not_run"
+        log_info "Build check: a build system is present but not auto-run -> honest gap (not verified)"
+    elif [ "$applicable" = "true" ]; then
+        # EXECUTION is expensive (a real vite/webpack/go/cargo build, seconds to
+        # minutes) so we run it AT MOST ONCE per build run, not every iteration --
+        # honoring the "fastest / lowest cost" goal. A freshness marker (mirrors the
+        # test-results.iter pattern) records that the build already ran this run; a
+        # later iteration reuses the recorded verified/failed status instead of
+        # re-building. LOKI_BUILD_CHECK=0 opts out entirely (records N/A-style skip
+        # without running). If a prior result exists and is still valid, keep it.
+        local marker="$quality_dir/.build-check.done"
+        if [ "${LOKI_BUILD_CHECK:-1}" = "0" ]; then
+            log_info "Build check: execution disabled (LOKI_BUILD_CHECK=0); recording applicability only"
+            ran="false"; exit_code="null"; status="not_run"
+        elif [ -f "$marker" ] && [ -f "$out_file" ]; then
+            log_info "Build check: already ran this build; reusing recorded result"
+            return 0
+        else
+            local rc=0
+            ( cd "$tree" && timeout "$timeout_s" sh -c "$cmd" >/dev/null 2>&1 ) || rc=$?
+            ran="true"; exit_code="$rc"
+            if [ "$rc" -eq 0 ]; then status="verified"; else status="failed"; fi
+            : > "$marker" 2>/dev/null || true
+            log_info "Build check: $cmd -> exit $rc"
+        fi
+    else
+        # build_class="none": a POSITIVE proof-of-no-build determination -> honest
+        # N/A (the founder's CLI). applicable already false; status not_applicable.
+        applicable="false"; ran="false"; status="not_applicable"
+        log_info "Build check: no build step for this stack (N/A)"
+    fi
+
+    printf '{"timestamp":"%s","command":"%s","ran":%s,"applicable":%s,"exit_code":%s,"duration_sec":null,"status":"%s"}\n' \
+        "$ts" "$cmd" "$ran" "$applicable" "$exit_code" "$status" > "$out_file"
+    return 0
+}
+
 enforce_static_analysis() {
     local loki_dir="${TARGET_DIR:-.}/.loki"
     local quality_dir="$loki_dir/quality"
@@ -9160,6 +9317,21 @@ _loki_zero_tests_executed() {
             fi
             return 1
             ;;
+        unittest)
+            # #139: `python3 -m unittest discover` on ZERO discovered tests prints
+            # "Ran 0 tests" + "NO TESTS RAN". Depending on the Python version it
+            # exits 5 (newer, already not-pass) OR 0 (older = a silent fake-green,
+            # the #82/#89 trap). POSITIVE detection so it is inconclusive on BOTH:
+            # a "Ran 0 tests" line (authoritative), or the "NO TESTS RAN" banner,
+            # AND no ran-count >= 1. A real run prints "Ran N test(s)" with N>=1
+            # and "OK"/"FAILED", so it is never downgraded. Verified live: zero ->
+            # "Ran 0 tests"/"NO TESTS RAN"; one -> "Ran 1 test"/"OK".
+            if printf '%s' "$_zt_out" | grep -qE '^Ran 0 tests' 2>/dev/null \
+               || printf '%s' "$_zt_out" | grep -qE '^NO TESTS RAN$' 2>/dev/null; then
+                return 0
+            fi
+            return 1
+            ;;
         *)
             # Unknown/unparseable runner -> never claim zero-tests (safe default).
             return 1
@@ -9326,6 +9498,17 @@ sys.stdout.write(t.strip())
                 -print -quit 2>/dev/null | grep -q .; then
                 has_python_project=true
             fi
+        elif find "${TARGET_DIR:-.}" -maxdepth 2 -type f \
+                \( -name 'test_*.py' -o -name '*_test.py' \) \
+                -not -path '*/.loki/*' -not -path '*/.git/*' -not -path '*/node_modules/*' \
+                -not -path '*/.venv/*' -not -path '*/venv/*' \
+                -print -quit 2>/dev/null | grep -q .; then
+            # #139: a ROOT-LEVEL (or shallow) test_*.py / *_test.py with NO tests/
+            # dir and NO config file. The founder's invoice CLI had exactly this
+            # shape (test_invoice_cli.py at the root) -> was missed -> tests read
+            # "not run" on a genuinely-passing 16-test unittest suite. This is the
+            # same false-negative class as #79 (validated work reads as unvalidated).
+            has_python_project=true
         fi
         if [ "$has_python_project" = "true" ] && command -v pytest &>/dev/null; then
             test_runner="pytest"
@@ -9342,6 +9525,29 @@ sys.stdout.write(t.strip())
                 [ "$pytest_exit" -ne 0 ] && test_passed=false
                 details="pytest: $(echo "$output" | tail -5 | tr '\n' ' ')"
             fi
+        elif [ "$has_python_project" = "true" ] && command -v python3 &>/dev/null; then
+            # #139: pytest ABSENT but a Python test suite exists. stdlib unittest
+            # discovery runs test_*.py with ZERO third-party deps -- so a legit
+            # unittest suite (the invoice CLI's 16 tests) is verified instead of
+            # silently read as "not run". The zero-test guard (unittest case) makes
+            # a zero-discovery run inconclusive, NOT a fake-green pass (unittest
+            # prints "NO TESTS RAN" and exits 0 -- the #82/#89 trap, guarded).
+            test_runner="unittest"
+            local output unittest_exit _ut_to
+            _ut_to="${LOKI_PYTEST_TIMEOUT:-${LOKI_GATE_TIMEOUT:-300}}"
+            local _ut_cmd=(timeout "${_ut_to}s")
+            command -v gtimeout &>/dev/null && _ut_cmd=(gtimeout "${_ut_to}s")
+            command -v timeout &>/dev/null || command -v gtimeout &>/dev/null || _ut_cmd=()
+            output=$(cd "${TARGET_DIR:-.}" && "${_ut_cmd[@]}" python3 -m unittest discover -p 'test_*.py' 2>&1)
+            unittest_exit=$?
+            if [ "$unittest_exit" -eq 124 ]; then
+                test_passed=false
+                log_warn "unittest gate timed out after ${_ut_to}s (exit 124)"
+                details="unittest: TIMED OUT after ${_ut_to}s -- $(echo "$output" | tail -3 | tr '\n' ' ')"
+            else
+                [ "$unittest_exit" -ne 0 ] && test_passed=false
+                details="unittest: $(echo "$output" | tail -5 | tr '\n' ' ')"
+            fi
         fi
     fi
 
@@ -17574,6 +17780,14 @@ if __name__ == "__main__":
                 fi
                 emit_stage_complete "static_analysis" "$_stg_ok" "$_stg_t0"
             fi
+            # Build check (#47). Records .loki/quality/build-results.json each
+            # iteration so the Evidence Receipt tells the truth about the build:
+            # a real build that ran (verified/failed) or an HONEST N/A when the
+            # stack has no build step. Advisory (best-effort): a build failure
+            # surfaces as a receipt gap via facts.build, never a hard loop block,
+            # mirroring the security scan. Absent writer historically = facts.build
+            # permanently not_run for every project (the founder-reported defect).
+            enforce_build_check || true
             # Secure-by-default scan (v7.87.0). Advisory by default (never
             # blocks); records .loki/quality/security-findings.json each
             # iteration. Blocks only on un-waived HIGH when LOKI_SECURE_GATE=block.

package/autonomy/verify.sh

@@ -350,6 +350,18 @@ _verify_zero_tests_executed() {
             fi
             return 1
             ;;
+        unittest)
+            # #139: `python3 -m unittest discover` on ZERO discovered tests prints
+            # "Ran 0 tests" + "NO TESTS RAN". On older Python it EXITS 0 (a silent
+            # fake-green), on newer it exits 5 (already not-pass). POSITIVE detection
+            # so it is inconclusive on BOTH. A real run prints "Ran N test(s)" (N>=1)
+            # + "OK"/"FAILED" -> never downgraded. Mirrors run.sh's guard exactly.
+            if printf '%s' "$_zt_out" | grep -qE '^Ran 0 tests' 2>/dev/null \
+               || printf '%s' "$_zt_out" | grep -qE '^NO TESTS RAN$' 2>/dev/null; then
+                return 0
+            fi
+            return 1
+            ;;
         *)
             return 1
             ;;
@@ -421,9 +433,19 @@ verify_gate_tests() {
             if command -v pytest >/dev/null 2>&1; then
                 runner="pytest"
                 out="$(cd "$tree" && timeout "$timeout_s" 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
+                # inconclusive. A real passing test_*.py suite is now VERIFIED here
+                # too, matching run.sh's enforce_test_coverage. Zero-discovery is
+                # handled below (unittest exits 5 on newer Python = fail-not-pass, or
+                # 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=$?
             else
                 # Applicable but cannot run -> inconclusive (Entanglement 2).
-                _verify_add_gate "tests" "inconclusive" "pytest" "python project detected but pytest not on PATH" "true"
+                _verify_add_gate "tests" "inconclusive" "pytest" "python project detected but no pytest/python3 on PATH" "true"
                 return 0
             fi
         fi

package/dashboard/__init__.py

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

package/docs/EVIDENCE-RECEIPT-BUILD-APPLICABILITY.md

@@ -0,0 +1,79 @@
+# Evidence Receipt: honest build applicability (done once, for all customers)
+
+## The defect (founder-reported, 2026-07-03)
+
+A sophisticated user built a Node CLI (invoice tool) and saw the Evidence Receipt say
+"Build: not run - build not run", "Live health check: not captured", "No screenshot",
+headline "Working, with gaps". He concluded *nothing was validated* -- and that read is the
+bug: it destroys trust in genuinely-validated work.
+
+## Ground truth (from the persisted proof of run-20260703034719)
+
+- `facts.tests` = `verified`, exit 0 -- tests GENUINELY ran and passed.
+- `facts.security` = `ran:true, clean` -- security GENUINELY ran, real clean scan.
+- `facts.build` = `ran:false, status:not_run, command:""` -- and this is counted as a GAP
+  by `_compute_degraded` (proof-generator.py:903-908), which forces "WITH GAPS".
+- `facts.quality_gates` = `[]` (EMPTY) -- verify.sh's deterministic build gate does NOT
+  reach the SaaS proof.
+
+## Root cause (systemic, every build, every customer)
+
+`build-results.json` has **NO writer**. `_collect_build` (proof-generator.py:319) reads
+`.loki/quality/build-results.json`, which nothing ever writes, so `facts.build` defaults to
+`not_run` (line 333) for EVERY build. The sibling collectors DO have writers in run.sh
+(`enforce_static_analysis` 8357, `run_secure_scan` 8720, `enforce_test_coverage` 9170 ->
+test-results.json / security-findings.json / static-analysis.json). Build was never wired.
+
+So "Build: not run" is not a per-project decision -- it is a permanent, structural
+mislabel. A build that has no build step (a CLI) and a build that genuinely skipped a real
+build both read identically as "not run" and both count as a gap.
+
+## The fix (honest, no fabrication, no mocking -- the founder's hard constraint)
+
+Add the missing writer as a sibling collector, with a POSITIVE applicability determination:
+
+1. **run.sh `enforce_build_check()`** (new, sibling to enforce_static_analysis): detect the
+   stack's build command (npm "build" script / go build / cargo build -- same detectors as
+   verify.sh:250-291). Then:
+   - build command exists -> RUN it -> record `{ran:true, command, exit_code, status:
+     verified|failed}`.
+   - genuinely NO build step for this stack -> record `{ran:false, applicable:false,
+     status:not_applicable, command:""}`. This is a POSITIVE "no build phase" signal, not an
+     absent file.
+   Write `.loki/quality/build-results.json`. Call it where the sibling collectors are called.
+
+2. **proof-generator.py `_collect_build`**: pass through `applicable:false` -> status
+   `not_applicable`. CRITICAL: `not_applicable` ONLY from an explicit `applicable:false` in
+   the file. File ABSENT or unknown status -> `not_run` (honest gap), NEVER N/A. Absent must
+   never mean N/A (that would flip un-built projects green -- fake-green).
+
+3. **proof-generator.py `_compute_degraded`**: `not_applicable` is NOT a gap (excluded from
+   the weak set for build). A failed/skipped/not_run build stays a gap. Mirror-image guard:
+   a real build script that FAILS still emits `failed` -> gap -> never green.
+
+4. **proof-generator.py status normalizer (line 215)**: `not_applicable` passes through.
+
+5. **SPA adapter.ts**: `not_applicable` renders "N/A - no build step for this stack" (a
+   neutral/pass tier, NOT a warn/gap), distinct from "not run".
+
+## Anti-fake-green invariants (the trust moat)
+
+- N/A ONLY on positive `applicable:false`. Absent file / unknown status -> honest gap.
+- A build script that got skipped or failed STILL shows a gap and CANNOT go green.
+- The directional regression test (write FIRST): Node project WITH a build script whose
+  build FAILS -> `facts.build=failed` -> degraded -> headline NOT green. And: build gate
+  MISSING -> still a gap, not N/A.
+- N/A does not gate the seal any more than a gap does; it is honest applicability, not a pass.
+
+## Measurable before/after
+
+Before: invoice CLI -> "Build: not run", headline "Working, with gaps".
+After: fresh invoice CLI build -> "Build: N/A (no build step for this stack)", tests passed,
+security scanned-clean, headline VERIFIED (no un-closed applicable gaps).
+
+## Constraints
+
+Verdict-core: council 3/3 + local-ci + 14 version locations. Verify via
+function-extraction/golden harness -- NEVER run the engine build from the worktree. Run the
+EXISTING tests/test_proof_generator.py green before AND after (it has build-results.json
+fixtures that this change touches). Deploy to live SaaS is `bun install -g loki-mode@<ver>`.

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.118.0
+**Version:** v7.120.0
 
 ---
 

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.118.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}
+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.120.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=01D367D3C33A5E7664756E2164756E21
+//# debugId=4C6F828B3BD8743B64756E2164756E21

package/mcp/__init__.py

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

package/package.json

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