loki-mode 7.117.2 → 7.119.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.117.2
+# Loki Mode v7.119.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.117.2 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.119.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.117.2
+7.119.0

package/autonomy/completion-council.sh

@@ -92,6 +92,42 @@ COUNCIL_MIN_ITERATIONS=${LOKI_COUNCIL_MIN_ITERATIONS:-3}
 if [ "$COUNCIL_MIN_ITERATIONS" -lt 1 ] 2>/dev/null; then
     COUNCIL_MIN_ITERATIONS=1
 fi
+
+# _council_effective_min_iter (SaaS #122): resolve the effective MIN_ITERATIONS
+# floor as a function of DETECTED_COMPLEXITY, computed at council-run time (NOT at
+# source time -- DETECTED_COMPLEXITY is populated by run.sh:detect_complexity
+# before the loop, but AFTER this file is sourced). The floor is a HARD gate in
+# council_should_stop: while ITERATION_COUNT < floor the council is not allowed to
+# even evaluate, so a genuinely-complete SIMPLE app (e.g. a small invoice app) that
+# claims done at iteration 1 was still FORCED through ~2 extra idle iterations
+# (~15min) before the council could approve. Lowering the floor to 1 for the
+# `simple` tier removes only those FORCED idle iterations; it does NOT skip any
+# verification. At floor=1, `ITERATION_COUNT=1` makes `1 -lt 1` false, so the
+# council is ALLOWED to convene -- the evidence gate, checklist gate, aggregate
+# vote, provenance, boot smoke and devil's advocate all still run and can still
+# reject. Standard/complex keep floor 3.
+#
+# Precedence (the explicit-override case must win so a user who sets
+# LOKI_COUNCIL_MIN_ITERATIONS=3 on a simple app is honored, not silently lowered):
+#   1. explicit LOKI_COUNCIL_MIN_ITERATIONS env set (non-empty) -> that value
+#      (already clamped into COUNCIL_MIN_ITERATIONS above), verbatim.
+#   2. DETECTED_COMPLEXITY == simple (default floor, no override) -> 1.
+#   3. otherwise -> COUNCIL_MIN_ITERATIONS (the standard/complex default of 3).
+# When DETECTED_COMPLEXITY is empty (unset) this returns COUNCIL_MIN_ITERATIONS --
+# a no-op that preserves the historical standard-path behavior.
+_council_effective_min_iter() {
+    # Explicit user override wins: read the RAW env var (COUNCIL_MIN_ITERATIONS
+    # collapses "user set 3" and "default 3" into one value and can't distinguish).
+    if [ -n "${LOKI_COUNCIL_MIN_ITERATIONS:-}" ]; then
+        printf '%s' "${COUNCIL_MIN_ITERATIONS}"
+        return 0
+    fi
+    if [ "${DETECTED_COMPLEXITY:-}" = "simple" ]; then
+        printf '%s' 1
+        return 0
+    fi
+    printf '%s' "${COUNCIL_MIN_ITERATIONS}"
+}
 COUNCIL_CONVERGENCE_WINDOW=${LOKI_COUNCIL_CONVERGENCE_WINDOW:-3}
 COUNCIL_STAGNATION_LIMIT=${LOKI_COUNCIL_STAGNATION_LIMIT:-5}
 COUNCIL_DONE_SIGNAL_LIMIT=${LOKI_COUNCIL_DONE_SIGNAL_LIMIT:-10}
@@ -3470,7 +3506,10 @@ _council_should_check_now() {
     local completion_claimed="${2:-false}"
     local iter="${ITERATION_COUNT:-0}"
     local interval="${COUNCIL_CHECK_INTERVAL:-5}"
-    local min_iter="${COUNCIL_MIN_ITERATIONS:-3}"
+    # SaaS #122: tier-aware effective floor (simple->1) so the no-claim early
+    # check can also fire at iteration 1 on a genuinely-done simple app.
+    local min_iter
+    min_iter="$(_council_effective_min_iter)"
 
     # Circuit breaker and explicit-claim paths are UNCHANGED (they already bypass
     # the interval); return check-now for them without touching the early logic.
@@ -3505,8 +3544,16 @@ council_should_stop() {
         return 1  # Council disabled, don't stop
     fi
 
-    # Don't check before minimum iterations
-    if [ "$ITERATION_COUNT" -lt "$COUNCIL_MIN_ITERATIONS" ]; then
+    # Don't check before minimum iterations. SaaS #122: the floor is tier-aware
+    # (simple->1) via _council_effective_min_iter so a genuinely-complete simple
+    # app that claims done at iteration 1 is not FORCED through ~2 extra idle
+    # iterations before the council may evaluate. This only changes WHETHER the
+    # council is allowed to convene early; every verification gate inside
+    # council_evaluate still runs and can still reject. Standard/complex keep 3,
+    # and an explicit LOKI_COUNCIL_MIN_ITERATIONS override is always honored.
+    local _min_iter
+    _min_iter="$(_council_effective_min_iter)"
+    if [ "$ITERATION_COUNT" -lt "$_min_iter" ]; then
         return 1
     fi
 

package/autonomy/hooks/migration-hooks.sh

@@ -652,6 +652,288 @@ with open(sys.argv[1], 'w') as f:
     return 0
 }
 
+#===============================================================================
+# RANK 4: Golden-master boundary-equivalence for heal/migrate
+#
+# The whole-suite exit-code check in hook_healing_phase_gate is necessary but not
+# sufficient: a transform can keep unit tests green while ALTERING an observable
+# boundary (CLI stdout, HTTP response, file/DB delta). Golden-master capture
+# records the OBSERVED output of each detected boundary during archaeology; the
+# modernize->validate gate re-runs each boundary and compares to that baseline
+# PER-BOUNDARY. A changed boundary is BLOCKED unless a documented-intentional-
+# change record exists for exactly that boundary.
+#
+# These are deterministic shell/python functions (NOT LLM calls), consistent with
+# the file contract at the top: they run whether the agent cooperates or not.
+#===============================================================================
+
+# Enumerate the boundaries to golden-master. Sources of truth (all merged, first
+# occurrence of a boundary id wins):
+#   1. .loki/healing/boundaries.json    -- canonical heal boundary manifest that
+#      archaeology is instructed to write (see the heal prompt). Array of
+#      {id, boundary_type, command} (or `characterization_test`).
+#   2. .loki/healing/features.json      -- the migrate-flow feature list; each
+#      entry's `characterization_test` is a reproducible boundary invocation.
+#   3. .loki/healing/characterization-tests/*.json -- per-boundary characterization
+#      files (heal archaeology's tool output); any object carrying a runnable
+#      `command`/`characterization_test`/`cmd` field is a boundary.
+# heal writes (1) and/or (3); migrate writes (2). Reading all three keeps the
+# golden-master populated in BOTH real flows, not just the synthetic fixture.
+# Emits one TSV line per boundary: <boundary_id>\t<invocation_command>
+# Prints nothing (returns 0) when no boundaries are detectable -- callers must
+# treat "no boundaries" as an honest degrade, never a green verdict.
+_heal_enumerate_boundaries() {
+    local heal_dir="$1"
+    HEAL_DIR="$heal_dir" python3 -c "
+import json, os, sys, glob
+
+heal_dir = os.environ['HEAL_DIR']
+seen = set()
+out = []
+
+def emit(bid, cmd):
+    if not cmd or not str(cmd).strip():
+        return
+    bid = str(bid).replace('\t', ' ').replace('\n', ' ').strip()
+    if not bid or bid in seen:
+        return
+    seen.add(bid)
+    out.append((bid, str(cmd).replace('\n', ' ').replace('\r', ' ')))
+
+def cmd_of(it):
+    for k in ('command', 'characterization_test', 'cmd'):
+        v = it.get(k)
+        if v and str(v).strip():
+            return v
+    return None
+
+def id_of(it, default='boundary'):
+    fid = it.get('id') or it.get('name') or it.get('description') or default
+    btype = it.get('boundary_type') or it.get('category') or it.get('type') or 'cli'
+    return '%s:%s' % (btype, fid)
+
+def load(path):
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+# (1) canonical heal boundary manifest
+data = load(os.path.join(heal_dir, 'boundaries.json'))
+if data is not None:
+    items = data if isinstance(data, list) else data.get('boundaries', data.get('features', []))
+    for it in items if isinstance(items, list) else []:
+        if isinstance(it, dict):
+            emit(id_of(it), cmd_of(it))
+
+# (2) migrate feature list
+data = load(os.path.join(heal_dir, 'features.json'))
+if data is not None:
+    items = data if isinstance(data, list) else data.get('features', [])
+    for it in items if isinstance(items, list) else []:
+        if isinstance(it, dict):
+            emit(id_of(it), cmd_of(it))
+
+# (3) per-boundary characterization files
+for path in sorted(glob.glob(os.path.join(heal_dir, 'characterization-tests', '*.json'))):
+    data = load(path)
+    if data is None:
+        continue
+    items = data if isinstance(data, list) else [data]
+    for it in items:
+        if isinstance(it, dict) and cmd_of(it):
+            base = os.path.splitext(os.path.basename(path))[0]
+            emit(id_of(it, default=base), cmd_of(it))
+
+for bid, cmd in out:
+    print('%s\t%s' % (bid, cmd))
+" 2>/dev/null || true
+}
+
+# Stable, filesystem-safe filename for a boundary id's golden-master artifact.
+_heal_boundary_artifact_name() {
+    local bid="$1"
+    # sha of the id keeps names stable + collision-free across weird chars.
+    local h
+    h=$(printf '%s' "$bid" | shasum 2>/dev/null | awk '{print $1}')
+    [[ -z "$h" ]] && h=$(printf '%s' "$bid" | cksum | awk '{print $1}')
+    printf 'boundary-%s.json' "$h"
+}
+
+# Run a single boundary invocation and capture OBSERVED output as a golden-master
+# artifact. Captures stdout (the compared channel) + exit code + the reproduction
+# command (so validate can re-run it). stderr is captured into a separate field and
+# is NOT compared: on a real Py2->Py3 boundary stderr carries DeprecationWarnings
+# and tracebacks that vary run-to-run and would false-block equivalence.
+# Deterministic-by-contract: the boundary command's STDOUT must not emit
+# nondeterministic tokens (timestamps/pids); normalization of such is a documented
+# limitation for the real integration, out of scope for the deterministic core.
+# Returns 0 on capture, 1 on failure to write.
+hook_capture_behavioral_baseline() {
+    local codebase_path="${1:-${LOKI_CODEBASE_PATH:-.}}"
+    local heal_dir="${codebase_path}/.loki/healing"
+    local baseline_dir="${heal_dir}/behavioral-baseline"
+
+    [[ "${LOKI_HEAL_MODE:-false}" != "true" ]] && return 0
+
+    mkdir -p "$baseline_dir" 2>/dev/null || return 1
+
+    local captured=0
+    local any=0
+    while IFS=$'\t' read -r bid cmd; do
+        [[ -z "$bid" || -z "$cmd" ]] && continue
+        any=1
+        local out rc art errf
+        errf=$(mktemp)
+        # stdout is the compared channel; stderr is diverted to $errf (recorded
+        # separately, never compared).
+        out=$(cd "$codebase_path" && eval "$cmd" 2>"$errf")
+        rc=$?
+        local err
+        err=$(cat "$errf" 2>/dev/null); rm -f "$errf"
+        art="$baseline_dir/$(_heal_boundary_artifact_name "$bid")"
+        # Write a self-describing artifact: id + reproduction command + observed
+        # stdout (compared) + stderr (recorded, not compared) + observed exit.
+        # validate re-runs `command` and compares stdout+exit only.
+        if BID="$bid" CMD="$cmd" OUT="$out" ERR="$err" RC="$rc" ART="$art" python3 -c "
+import json, os
+art = {
+    'boundary': os.environ['BID'],
+    'boundary_type': os.environ['BID'].split(':', 1)[0],
+    'command': os.environ['CMD'],
+    'stdout': os.environ['OUT'],
+    'stderr': os.environ.get('ERR', ''),
+    'exit_code': int(os.environ['RC']),
+    'captured_by': 'hook_capture_behavioral_baseline',
+    'note': 'stdout+exit_code are the compared channels; stderr is informational only.',
+}
+with open(os.environ['ART'], 'w') as f:
+    json.dump(art, f, indent=2, sort_keys=True)
+" 2>/dev/null; then
+            captured=$((captured + 1))
+        fi
+    done < <(_heal_enumerate_boundaries "$heal_dir")
+
+    if [[ "$any" -eq 0 ]]; then
+        # Honest degrade: no boundaries detected. Do NOT fabricate artifacts.
+        echo "BASELINE: no boundaries detected (no runnable boundary command in boundaries.json / features.json / characterization-tests/); nothing to golden-master."
+        return 0
+    fi
+    echo "BASELINE: captured ${captured} golden-master artifact(s) into behavioral-baseline/"
+    return 0
+}
+
+# Compare current boundary outputs to the golden-master baseline PER-BOUNDARY.
+# Emits a diff report enumerating EVERY changed boundary. A boundary is "changed"
+# when its current stdout OR exit code differs from the baseline artifact, UNLESS
+# a documented-intentional-change record exists for exactly that boundary id in
+# behavioral-baseline/intentional-changes.json.
+# Echoes a human-readable report on stdout.
+# Returns:
+#   0  - no baseline / no boundaries (honest degrade; caller falls through), OR
+#        all boundaries equivalent (or every change documented-intentional).
+#   1  - at least one undocumented boundary change -> caller must BLOCK.
+hook_compare_behavioral_baseline() {
+    local codebase_path="${1:-${LOKI_CODEBASE_PATH:-.}}"
+    local heal_dir="${codebase_path}/.loki/healing"
+    local baseline_dir="${heal_dir}/behavioral-baseline"
+    local intentional="${baseline_dir}/intentional-changes.json"
+
+    # Honest degrade: off/greenfield/no-baseline -> byte-identical no-op. The
+    # caller falls through to its existing whole-suite check unchanged.
+    [[ "${LOKI_HEAL_MODE:-false}" != "true" ]] && return 0
+    [[ -d "$baseline_dir" ]] || return 0
+    # Any golden-master artifacts at all?
+    local art_count
+    art_count=$(find "$baseline_dir" -type f -name 'boundary-*.json' 2>/dev/null | wc -l | tr -d ' ')
+    if [[ "${art_count:-0}" -eq 0 ]]; then
+        echo "BOUNDARY-CHECK: no golden-master baseline present; skipping per-boundary comparison (honest degrade)."
+        return 0
+    fi
+
+    local changed=0
+    local report=""
+    local art
+    while IFS= read -r art; do
+        [[ -z "$art" ]] && continue
+        # Read stored boundary id + reproduction command in one python call. A
+        # trailing sentinel is appended to each so command-substitution's trailing
+        # -newline strip does not corrupt a value (bid/cmd are single-line by
+        # construction, but this keeps the read exact and robust).
+        local bid cmd base_rc
+        bid=$(ART="$art" python3 -c "import json,os;print(json.load(open(os.environ['ART']))['boundary'])" 2>/dev/null) || continue
+        cmd=$(ART="$art" python3 -c "import json,os;print(json.load(open(os.environ['ART']))['command'])" 2>/dev/null) || continue
+        base_rc=$(ART="$art" python3 -c "import json,os;print(json.load(open(os.environ['ART']))['exit_code'])" 2>/dev/null)
+
+        # Re-run the boundary NOW. stderr diverted (not compared), matching the
+        # capture channel; only stdout + exit are compared.
+        local cur_out cur_rc
+        cur_out=$(cd "$codebase_path" && eval "$cmd" 2>/dev/null)
+        cur_rc=$?
+
+        # Byte-exact stdout comparison via python (handles trailing newlines /
+        # binary-ish content that shell string compare would mangle).
+        if ART="$art" CUR="$cur_out" python3 -c "
+import json, os, sys
+base = json.load(open(os.environ['ART']))['stdout']
+sys.exit(0 if base == os.environ['CUR'] else 1)
+" 2>/dev/null && [[ "$cur_rc" == "$base_rc" ]]; then
+            continue
+        fi
+        # Recover baseline stdout for the report (may be multi-line).
+        local base_out
+        base_out=$(ART="$art" python3 -c "import json,os,sys;sys.stdout.write(json.load(open(os.environ['ART']))['stdout'])" 2>/dev/null)
+
+        # Boundary changed. Is it documented-intentional for THIS boundary id?
+        local is_doc="false"
+        if [[ -f "$intentional" ]]; then
+            is_doc=$(INT="$intentional" BID="$bid" python3 -c "
+import json, os
+try:
+    data = json.load(open(os.environ['INT']))
+except Exception:
+    print('false'); raise SystemExit
+changes = data.get('changes', []) if isinstance(data, dict) else []
+bid = os.environ['BID']
+for c in changes:
+    if isinstance(c, dict) and c.get('boundary') == bid and c.get('is_intentional') is True:
+        print('true'); break
+else:
+    print('false')
+" 2>/dev/null || echo false)
+        fi
+
+        if [[ "$is_doc" == "true" ]]; then
+            report+="  [documented-intentional] ${bid}: change accepted (intentional-changes.json)"$'\n'
+            continue
+        fi
+
+        changed=$((changed + 1))
+        report+="  [CHANGED] ${bid}"$'\n'
+        report+="    command:  ${cmd}"$'\n'
+        report+="    baseline: exit=${base_rc} stdout=$(printf '%q' "$base_out")"$'\n'
+        report+="    current:  exit=${cur_rc} stdout=$(printf '%q' "$cur_out")"$'\n'
+    done < <(find "$baseline_dir" -type f -name 'boundary-*.json' 2>/dev/null)
+
+    if [[ "$changed" -gt 0 ]]; then
+        echo "BOUNDARY-DIFF REPORT (${changed} undocumented boundary change(s)):"
+        printf '%s' "$report"
+        echo "  To accept a change intentionally, add a record to:"
+        echo "    ${intentional}"
+        echo "    {\"changes\":[{\"boundary\":\"<id>\",\"is_intentional\":true,\"reason\":\"...\"}]}"
+        return 1
+    fi
+
+    if [[ -n "$report" ]]; then
+        echo "BOUNDARY-CHECK: all changed boundaries are documented-intentional:"
+        printf '%s' "$report"
+    else
+        echo "BOUNDARY-CHECK: all ${art_count} boundary(ies) equivalent to golden-master baseline."
+    fi
+    return 0
+}
+
 # Hook: healing_phase_gate - mechanical verification before healing phase transition
 hook_healing_phase_gate() {
     local from_phase="${1:-}"
@@ -748,6 +1030,20 @@ except: print(0)
                 echo "GATE_BLOCKED: Tests do not pass after modernization"
                 return 1
             fi
+            # RANK 4: whole-suite exit code is necessary but NOT sufficient. A
+            # transform can keep unit tests green while altering an observable
+            # boundary. Compare each boundary to its golden-master baseline; block
+            # any undocumented boundary change. Honest degrade (no baseline / no
+            # boundaries) falls through as a no-op -- never a false-green.
+            local boundary_report boundary_rc
+            boundary_report=$(hook_compare_behavioral_baseline "$codebase_path")
+            boundary_rc=$?
+            if [[ "$boundary_rc" -ne 0 ]]; then
+                echo "GATE_BLOCKED: boundary equivalence violated after modernization (unit tests green but an observable boundary changed)."
+                echo "$boundary_report"
+                return 1
+            fi
+            [[ -n "$boundary_report" ]] && echo "$boundary_report"
             ;;
     esac
 

package/autonomy/lib/proof-generator.py

@@ -130,6 +130,46 @@ def _collect_council(loki_dir):
         rec = _read_json(os.path.join(votes_dir, vf), default=None)
         if not isinstance(rec, dict):
             continue
+        # completion-council.sh writes ROUND-SUMMARY files (round-N.json,
+        # devils-advocate-round-N.json) shaped
+        # {round, verdict, votes:[{member, role, vote, reason}]} -- NOT a flat
+        # per-reviewer record. When we see that shape, expand the nested votes[]
+        # into per-reviewer rows (the real trust signal) and adopt the round
+        # verdict; otherwise fall back to the flat single-record shape. Without
+        # this, rec.get("role") is empty and the proof's council section renders
+        # blank reviewers even though the council genuinely ran and voted (#125).
+        nested = rec.get("votes")
+        if isinstance(nested, list) and nested:
+            rv = str(rec.get("verdict") or rec.get("result") or "")
+            if rv and not final_verdict:
+                final_verdict = rv
+            if threshold is None and rec.get("threshold") is not None:
+                tm = rec.get("total_members")
+                threshold = (
+                    "%s/%s" % (rec.get("threshold"), tm)
+                    if tm is not None else rec.get("threshold")
+                )
+            round_tag = str(rec.get("round") or "")
+            da = "devil" in vf.lower()
+            for v in nested:
+                if not isinstance(v, dict):
+                    continue
+                role = str(v.get("role") or v.get("member") or "")
+                vote = str(v.get("vote") or v.get("decision") or "")
+                # Skip empty vote rows (a blank role AND blank vote is noise, not
+                # a reviewer) so the proof never shows a phantom "-> " reviewer.
+                if not role and not vote:
+                    continue
+                if da and role:
+                    role = "%s (devil's advocate)" % role
+                reviewers.append({
+                    "role": role,
+                    "vote": vote,
+                    "summary": str(
+                        v.get("reason") or v.get("summary") or v.get("rationale") or ""
+                    ) + (" [round %s]" % round_tag if round_tag else ""),
+                })
+            continue
         reviewers.append({
             "role": str(rec.get("role") or rec.get("reviewer") or ""),
             "vote": str(rec.get("vote") or rec.get("decision") or ""),
@@ -222,6 +262,57 @@ def _collect_quality_gates(loki_dir):
             total += 1
             if status == "passed":
                 passed += 1
+
+    # #125: run.sh does NOT write state/quality-gates.json; it writes the gate
+    # outcomes under .loki/quality/ (a "<gate>.pass" marker on pass, plus
+    # per-gate result JSONs). When the aggregate above is empty/absent, read the
+    # real per-gate artifacts so a build that genuinely ran+passed its gates is
+    # not reported as quality_gates:{passed:0,total:0} (a receipt understatement
+    # that reads as "no verification ran"). Deterministic FACT from disk markers,
+    # never an LLM opinion. Only fills gates the aggregate did not already cover.
+    if not gates:
+        quality_dir = os.path.join(loki_dir, "quality")
+        seen = set()
+        # (gate name in proof, marker/result filename stem under quality/)
+        markers = [
+            ("static_analysis", "static-analysis"),
+            ("unit_tests", "unit-tests"),
+        ]
+        for gate_name, stem in markers:
+            pass_marker = os.path.join(quality_dir, stem + ".pass")
+            result_json = os.path.join(quality_dir, stem + ".json")
+            status = None
+            if os.path.exists(pass_marker):
+                status = "passed"
+            elif os.path.exists(result_json):
+                rj = _read_json(result_json, default=None)
+                if isinstance(rj, dict):
+                    status = _norm_gate_status(
+                        rj.get("passed", rj.get("status", "not_run"))
+                    )
+            if status is not None:
+                gates.append({"name": gate_name, "status": status})
+                seen.add(gate_name)
+                total += 1
+                if status == "passed":
+                    passed += 1
+        # test-results.json carries the suite outcome even when no .pass marker
+        # (e.g. {status:"verified"} = tests ran and passed).
+        if "unit_tests" not in seen:
+            tr = _read_json(
+                os.path.join(quality_dir, "test-results.json"), default=None
+            )
+            if isinstance(tr, dict):
+                st = str(tr.get("status") or "")
+                if st in ("verified", "pass", "passed"):
+                    gates.append({"name": "unit_tests", "status": "passed"})
+                    total += 1
+                    passed += 1
+                elif st:
+                    gates.append(
+                        {"name": "unit_tests", "status": _norm_gate_status(st)}
+                    )
+                    total += 1
     return {"passed": passed, "total": total, "gates": gates}
 
 
@@ -250,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/loki

@@ -14784,7 +14784,7 @@ HEALING RULES:
 5. INCREMENTAL ONLY: Change ONE component at a time. Verify ALL characterization tests pass after each change.
 
 Phase-specific instructions:
-- archaeology: Map dependencies, catalog friction, extract knowledge, write characterization tests. Do NOT modify source code.
+- archaeology: Map dependencies, catalog friction, extract knowledge, write characterization tests. Do NOT modify source code. ALSO write .loki/healing/boundaries.json: a JSON array of the OBSERVABLE system boundaries (CLI commands, HTTP endpoints, file/DB-producing entrypoints). Each element: {\"id\": string, \"boundary_type\": \"cli\"|\"http\"|\"file\"|\"db\", \"command\": string}. The \"command\" MUST be a deterministic shell invocation that exercises that boundary and prints its observable output to stdout (avoid timestamps/PIDs). These commands are golden-mastered into .loki/healing/behavioral-baseline/ and re-run at the modernize->validate gate to block any undocumented boundary change. If no observable boundary exists, write an empty array [] (do NOT invent one).
 - stabilize: Add logging and observability. Extract config. Add type hints. Do NOT change behavior.
 - isolate: Create adapter interfaces at component boundaries. Add integration tests.
 - modernize: Replace components behind adapters. Verify characterization tests pass.
@@ -14845,6 +14845,16 @@ except Exception: pass
 
     emit_event healing cli complete "phase=$phase" "exit=$heal_exit" 2>/dev/null || true
 
+    # RANK 4: populate .loki/healing/behavioral-baseline/ during archaeology.
+    # The dir is mkdir'd above but was never populated; the modernize->validate
+    # gate needs a golden-master per detected boundary to compare against.
+    # Deterministic capture (NOT an LLM call): re-runs each boundary's
+    # characterization_test and records observed stdout+exit. Honest degrade when
+    # no boundaries are detected. Byte-identical no-op when the hook is absent.
+    if [ "$phase" = "archaeology" ] && type hook_capture_behavioral_baseline &>/dev/null; then
+        hook_capture_behavioral_baseline "$codebase_path" 2>/dev/null || true
+    fi
+
     if [ "$heal_exit" -eq 0 ]; then
         echo ""
         echo -e "${GREEN}Healing phase '${phase}' complete.${NC}"

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"
@@ -17574,6 +17731,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/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "7.117.2"
+__version__ = "7.119.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.117.2
+**Version:** v7.119.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.117.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.119.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=01CA3D14238C4AE464756E2164756E21
+//# debugId=7B2014E7E7C6AC4464756E2164756E21

package/mcp/__init__.py

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.117.2",
+  "version": "7.119.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.117.2",
+  "version": "7.119.0",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",

package/skills/healing.md

@@ -411,10 +411,28 @@ When `loki heal` is active, the code review specialist pool includes:
   failure-modes.json             # Cataloged failure modes
   institutional-knowledge.md     # Extracted tribal knowledge
   healing-progress.json          # Component-by-component healing status
-  behavioral-baseline/           # Pre-healing system-boundary outputs
+  boundaries.json                # Observable system boundaries (archaeology writes)
+  behavioral-baseline/           # Golden-master per-boundary outputs (archaeology captures)
   characterization-tests/        # Tests that capture current behavior
 ```
 
+### Golden-master boundary equivalence (modernize -> validate gate)
+
+Whole-suite exit code is necessary but NOT sufficient: a transform can keep unit
+tests green while altering an observable boundary (CLI stdout/exit, HTTP, file/DB
+delta). Archaeology writes `.loki/healing/boundaries.json` -- a JSON array of
+`{"id","boundary_type":"cli"|"http"|"file"|"db","command"}` -- where `command` is a
+deterministic invocation that prints the boundary's observable output. During
+archaeology each boundary is golden-mastered into `behavioral-baseline/`
+(stdout + exit are the compared channels; stderr is recorded but never compared,
+so Py2->Py3 warnings do not false-block). At the `modernize -> validate` gate every
+boundary is re-run and compared PER-BOUNDARY; any change is BLOCKED with a diff
+report unless a per-boundary record exists in
+`behavioral-baseline/intentional-changes.json`
+(`{"changes":[{"boundary":"<id>","is_intentional":true,"reason":"..."}]}`).
+Honest degrade: no boundaries / no baseline / heal mode off is a byte-identical
+no-op, never a false-green. (Deterministic shell hooks, not LLM calls.)
+
 **Progress Tracking:**
 ```json
 {