loki-mode 7.115.0 → 7.117.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.115.0
+# Loki Mode v7.117.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.115.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.117.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.115.0
+7.117.0

package/autonomy/completion-council.sh

@@ -1764,10 +1764,21 @@ except (json.JSONDecodeError, IOError, KeyError, ValueError):
     sys.exit(0)
 runner = d.get('runner', 'none')
 passed = d.get('pass', True)
+status = d.get('status', '')
+#82 (zero-test-file hardening): a runner that ran but executed ZERO real tests
+# (node --test on a *.test.js with no test() calls; jest --passWithNoTests with
+# no suites) records pass:"inconclusive" + status:"no_tests_run" -- a mini
+# fake-green when read as affirmative. The pass value is then the STRING
+# "inconclusive" (not the bool True/False), so the old else-branch (PASS) would
+# have counted it as green. Route it to INCONCLUSIVE (pass-through, never a
+# block): a real runner ran but proved nothing, exactly like runner=="none".
+# Only the boolean True passes as affirmative; only the boolean False blocks.
 if runner == 'none':
     print('PASS:none:true')
 elif passed is False:
     print('FAIL:%s:false' % runner)
+elif status == 'no_tests_run' or passed is not True:
+    print('INCONCLUSIVE:%s:true' % runner)
 else:
     print('PASS:%s:true' % runner)
 " 2>/dev/null || echo "INCONCLUSIVE:none:true")
@@ -1787,6 +1798,16 @@ else:
             test_inconclusive="true"
             test_inconclusive_reason="no_test_runner"
         fi
+        # #82: a real runner that executed ZERO tests (pass:"inconclusive" +
+        # status:"no_tests_run") is INCONCLUSIVE, not affirmative. Mirror the
+        # runner=="none" pass-through so it routes to the council instead of
+        # reading as green. Honest (not a block): test_fails stays "false".
+        # Not gated by LOKI_EVIDENCE_NO_TESTS_AFFIRMATIVE -- a zero-test run is
+        # never affirmative evidence regardless of that opt-out.
+        if [ "$_verdict" = "INCONCLUSIVE" ] && [ "$test_runner" != "none" ]; then
+            test_inconclusive="true"
+            test_inconclusive_reason="no_tests_executed"
+        fi
     else
         # Missing test-results.json: no suite was recorded at all. Like the
         # runner=="none" case this is not affirmative evidence, so classify it

package/autonomy/loki

@@ -14069,6 +14069,9 @@ cmd_heal_help() {
     echo "  validate       Verify behavioral equivalence with baseline"
     echo ""
     echo "Options:"
+    echo "  --assess             Read-only modernization readiness triage (maturity"
+    echo "                       level + ranked where-to-start targets); no changes"
+    echo "  --json               With --assess: emit the readiness report as JSON"
     echo "  --phase PHASE        Start from specific phase (default: archaeology)"
     echo "  --resume             Resume healing from last checkpoint"
     echo "  --status             Show healing progress"
@@ -14089,6 +14092,8 @@ cmd_heal_help() {
     echo "  LOKI_HEAL_STRICT            Block all behavioral changes (default: false)"
     echo ""
     echo "Examples:"
+    echo "  loki heal ./legacy-app --assess               # Readiness triage (read-only)"
+    echo "  loki heal ./legacy-app --assess --json         # Same, structured for dashboard"
     echo "  loki heal ./legacy-app                        # Full healing pipeline"
     echo "  loki heal ./legacy-app --phase archaeology     # Knowledge extraction only"
     echo "  loki heal ./legacy-app --archaeology-only      # Extract without modifying"
@@ -14136,6 +14141,8 @@ cmd_heal() {
     local do_status="false"
     local do_report="false"
     local do_friction_map="false"
+    local do_assess="false"
+    local assess_json="false"
     local archaeology_only="false"
     local strict="${LOKI_HEAL_STRICT:-false}"
     local compliance=""
@@ -14167,6 +14174,14 @@ cmd_heal() {
                 do_friction_map="true"
                 shift
                 ;;
+            --assess)
+                do_assess="true"
+                shift
+                ;;
+            --json)
+                assess_json="true"
+                shift
+                ;;
             --phase)
                 if [[ -z "${2:-}" ]]; then
                     echo -e "${RED}Error: --phase requires a value (archaeology|stabilize|isolate|modernize|validate)${NC}"
@@ -14302,6 +14317,311 @@ for f in data.get('frictions', []):
         return 0
     fi
 
+    # Modernization readiness triage (rank 13). READ-ONLY: scans the target with
+    # cheap deterministic heuristics (find/wc/grep counts via python's os.walk and
+    # in-python line counts) and prints a readiness report to STDOUT. It writes
+    # NOTHING into the target (no .loki dir, no state files) so it cannot mutate
+    # the codebase and needs zero flags beyond a path. Emitted before the
+    # path-init/mkdir block below, so no healing session is created.
+    if [ "$do_assess" = "true" ]; then
+        local assess_path="${codebase_path:-.}"
+        if [[ ! -d "$assess_path" ]]; then
+            echo -e "${RED}Error: Directory not found: $assess_path${NC}"
+            return 1
+        fi
+        if ! command -v python3 >/dev/null 2>&1; then
+            echo -e "${RED}Error: python3 is required for readiness assessment.${NC}"
+            return 1
+        fi
+        LOKI_ASSESS_PATH="$assess_path" \
+        LOKI_ASSESS_JSON="$assess_json" \
+        python3 - <<'PYASSESS'
+import json, os, re, sys
+
+root = os.environ.get('LOKI_ASSESS_PATH', '.')
+as_json = os.environ.get('LOKI_ASSESS_JSON', 'false') == 'true'
+
+# Directories we never descend into (VCS/deps/build noise). Keeps counts honest:
+# a vendored node_modules would otherwise dominate LOC and target ranking.
+SKIP_DIRS = {
+    '.git', '.hg', '.svn', 'node_modules', '.loki', 'vendor', 'dist', 'build',
+    '.next', '.venv', 'venv', '__pycache__', '.mypy_cache', '.pytest_cache',
+    'target', '.idea', '.vscode', 'coverage', '.gradle', 'bin', 'obj',
+}
+
+# Extension -> language label. Only source-ish extensions are counted for LOC;
+# unknown extensions are ignored (reported as 'other' only when they carry text).
+LANG_BY_EXT = {
+    '.py': 'Python', '.js': 'JavaScript', '.jsx': 'JavaScript', '.mjs': 'JavaScript',
+    '.cjs': 'JavaScript', '.ts': 'TypeScript', '.tsx': 'TypeScript', '.go': 'Go',
+    '.rb': 'Ruby', '.java': 'Java', '.kt': 'Kotlin', '.c': 'C', '.h': 'C',
+    '.cpp': 'C++', '.cc': 'C++', '.hpp': 'C++', '.cs': 'C#', '.php': 'PHP',
+    '.rs': 'Rust', '.swift': 'Swift', '.scala': 'Scala', '.sh': 'Shell',
+    '.bash': 'Shell', '.pl': 'Perl', '.pm': 'Perl', '.r': 'R', '.m': 'Objective-C',
+    '.lua': 'Lua', '.ex': 'Elixir', '.exs': 'Elixir', '.clj': 'Clojure',
+    '.vue': 'Vue', '.dart': 'Dart',
+}
+
+TEST_HINT = re.compile(r'(^|[/_.-])(test|tests|spec|specs|__tests__)([/_.-]|s?$|\.)', re.I)
+TODO_RE = re.compile(r'\b(TODO|FIXME|HACK|XXX)\b')
+
+# import/require line -> the referenced module basename(s). Deliberately cheap:
+# we only need a proxy for how many OTHER files reference a given file, to rank
+# isolated (low blast-radius) modules ABOVE coupled ones (playbook weeks 1-2).
+IMPORT_PATTERNS = [
+    re.compile(r'^\s*import\s+(?:[\w.]+\s+)?["\']?([\w./-]+)'),          # py/js/ts/go
+    re.compile(r'^\s*from\s+([\w./-]+)\s+import'),                        # python
+    re.compile(r'require\(\s*["\']([\w./-]+)["\']\s*\)'),                # node
+    re.compile(r'^\s*#include\s+[<"]([\w./-]+)[>"]'),                    # c/c++
+    re.compile(r'^\s*use\s+([\w:./-]+)'),                                # rust
+]
+
+files = []          # per-file records
+lang_loc = {}       # language -> total LOC
+lang_files = {}     # language -> file count
+total_loc = 0
+total_files = 0
+todo_count = 0
+has_tests = False
+big_files = []      # (loc, relpath)
+# module reference tallies: how many files import a given basename (no-ext)
+ref_counts = {}
+file_records = {}   # relpath -> record
+
+def stem(name):
+    b = os.path.basename(name)
+    for e in sorted(LANG_BY_EXT, key=len, reverse=True):
+        if b.endswith(e):
+            return b[:-len(e)]
+    return os.path.splitext(b)[0]
+
+for dirpath, dirnames, filenames in os.walk(root):
+    dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith('.git')]
+    for fn in filenames:
+        ext = os.path.splitext(fn)[1].lower()
+        lang = LANG_BY_EXT.get(ext)
+        if lang is None:
+            continue
+        full = os.path.join(dirpath, fn)
+        try:
+            with open(full, 'r', encoding='utf-8', errors='replace') as fh:
+                lines = fh.readlines()
+        except (OSError, IOError):
+            continue
+        loc = len(lines)
+        rel = os.path.relpath(full, root)
+        total_loc += loc
+        total_files += 1
+        lang_loc[lang] = lang_loc.get(lang, 0) + loc
+        lang_files[lang] = lang_files.get(lang, 0) + 1
+        is_test = bool(TEST_HINT.search(rel))
+        if is_test:
+            has_tests = True
+        ftodo = 0
+        refs = set()
+        for ln in lines:
+            if TODO_RE.search(ln):
+                ftodo += 1
+            for pat in IMPORT_PATTERNS:
+                m = pat.search(ln)
+                if m:
+                    refs.add(stem(m.group(1)))
+        todo_count += ftodo
+        rec = {
+            'path': rel, 'loc': loc, 'language': lang,
+            'todos': ftodo, 'is_test': is_test,
+        }
+        files.append(rec)
+        file_records[rel] = rec
+        if loc >= 500:
+            big_files.append((loc, rel))
+        # tally inbound references toward the imported basenames
+        for r in refs:
+            ref_counts[r] = ref_counts.get(r, 0) + 1
+
+# Attach inbound-reference (blast-radius proxy) to each non-test source file.
+for rec in files:
+    rec['inbound_refs'] = ref_counts.get(stem(rec['path']), 0)
+
+# --- Technical-debt / maintenance-risk signals (all deterministic) ---
+big_files.sort(reverse=True)
+largest_loc = big_files[0][0] if big_files else 0
+# dependency-manifest presence (a real, cheap signal; NOT a staleness figure).
+manifest_names = {
+    'package.json', 'requirements.txt', 'Pipfile', 'pyproject.toml', 'go.mod',
+    'Cargo.toml', 'pom.xml', 'build.gradle', 'Gemfile', 'composer.json',
+}
+lockfile_names = {
+    'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'poetry.lock',
+    'Pipfile.lock', 'go.sum', 'Cargo.lock', 'Gemfile.lock', 'composer.lock',
+}
+found_manifests, found_lockfiles = [], []
+for fn in sorted(os.listdir(root)) if os.path.isdir(root) else []:
+    if fn in manifest_names:
+        found_manifests.append(fn)
+    if fn in lockfile_names:
+        found_lockfiles.append(fn)
+# dependency staleness is NOT computed offline -> reported as 'unknown', never guessed.
+dep_lock_present = len(found_lockfiles) > 0 if found_manifests else None
+
+todo_density = round((todo_count / total_loc) * 1000, 2) if total_loc else 0.0
+
+# --- 4-level maturity model (Ad hoc -> Planned -> Systematic -> Optimized) ---
+# Deterministic rubric from cheap signals. Higher = more modern/ready.
+# Ad hoc: no tests. Planned: tests exist but sparse / large files / high TODO.
+# Systematic: tests + locked deps + no oversized files + low TODO density.
+# Optimized: Systematic AND a strong test footprint (>=20% of source files test).
+test_files = sum(1 for f in files if f['is_test'])
+test_ratio = round(test_files / total_files, 3) if total_files else 0.0
+if not has_tests:
+    maturity = 'Ad hoc'
+    maturity_level = 1
+    maturity_reason = 'No test/spec files detected: changes are unguarded.'
+elif (test_ratio < 0.10) or (largest_loc >= 1000) or (todo_density >= 5.0):
+    maturity = 'Planned'
+    maturity_level = 2
+    maturity_reason = ('Tests exist but coverage footprint is thin or debt signals are high '
+                       '(sparse tests / oversized files / dense TODOs).')
+elif dep_lock_present and test_ratio >= 0.20:
+    maturity = 'Optimized'
+    maturity_level = 4
+    maturity_reason = ('Strong test footprint, pinned dependencies, and no oversized files: '
+                       'ready for continuous background modernization.')
+else:
+    maturity = 'Systematic'
+    maturity_level = 3
+    maturity_reason = ('Tests present with a healthy footprint and contained file sizes; '
+                       'dependency pinning or test depth can still improve.')
+
+# --- Ranked candidate targets (playbook weeks 1-2: low blast-radius FIRST) ---
+# AC#2 requires isolated / low-blast-radius modules to rank ABOVE coupled ones,
+# so isolation is the PRIMARY key -- it must never be traded away for size. We
+# bucket by inbound-reference tier (0 refs = isolated, 1-2 = low, 3-5 = moderate,
+# 6+ = highly coupled); within a tier, higher "visibility" (LOC + TODO weight)
+# breaks the tie so a bigger isolated file surfaces first. A large-but-coupled
+# file can therefore never outrank a small isolated one. Tests are excluded.
+candidates = [f for f in files if not f['is_test']]
+def blast_tier(refs):
+    if refs == 0:
+        return 0  # isolated
+    if refs <= 2:
+        return 1  # low blast radius
+    if refs <= 5:
+        return 2  # moderate
+    return 3      # highly coupled
+def visibility(f):
+    # tie-break WITHIN a blast tier only; bigger / more-flagged = more worth it.
+    return f['loc'] + f['todos'] * 50
+for f in candidates:
+    f['_tier'] = blast_tier(f['inbound_refs'])
+    f['_score'] = visibility(f)
+# primary: lower tier first (isolation dominates); secondary: higher visibility.
+candidates.sort(key=lambda f: (f['_tier'], -f['_score'], f['path']))
+top = candidates[:10]
+
+def target_rationale(f):
+    bits = []
+    if f['inbound_refs'] == 0:
+        bits.append('isolated (no inbound imports -> low blast radius)')
+    else:
+        bits.append(f"{f['inbound_refs']} inbound reference(s)")
+    bits.append(f"{f['loc']} LOC")
+    if f['todos']:
+        bits.append(f"{f['todos']} TODO/FIXME")
+    return ', '.join(bits)
+
+lang_mix = sorted(
+    ({'language': k, 'loc': v, 'files': lang_files.get(k, 0),
+      'pct': round((v / total_loc) * 100, 1) if total_loc else 0.0}
+     for k, v in lang_loc.items()),
+    key=lambda x: -x['loc'],
+)
+
+report = {
+    'codebase': os.path.abspath(root),
+    'scan': {
+        'total_files': total_files,
+        'total_loc': total_loc,
+        'language_mix': lang_mix,
+    },
+    'debt_signals': {
+        'has_tests': has_tests,
+        'test_files': test_files,
+        'test_ratio': test_ratio,
+        'todo_fixme_count': todo_count,
+        'todo_density_per_kloc': todo_density,
+        'large_files_ge_500_loc': len(big_files),
+        'largest_file_loc': largest_loc,
+    },
+    'maintenance_risk': {
+        'dependency_manifests': found_manifests,
+        'lockfiles': found_lockfiles,
+        'dependency_lock_present': dep_lock_present,
+        'dependency_staleness': 'unknown',  # not computable offline; never guessed
+    },
+    'maturity': {
+        'level': maturity_level,
+        'label': maturity,
+        'scale': ['Ad hoc', 'Planned', 'Systematic', 'Optimized'],
+        'rationale': maturity_reason,
+    },
+    'ranked_targets': [
+        {'path': f['path'], 'loc': f['loc'], 'language': f['language'],
+         'inbound_refs': f['inbound_refs'], 'todos': f['todos'],
+         'blast_tier': f['_tier'],  # 0 isolated, 1 low, 2 moderate, 3 highly coupled (primary sort key)
+         'visibility_score': f['_score'], 'rationale': target_rationale(f)}
+        for f in top
+    ],
+}
+
+if as_json:
+    print(json.dumps(report, indent=2))
+    sys.exit(0)
+
+BOLD = '\033[1m'; NC = '\033[0m'; CYAN = '\033[36m'
+print(f"{BOLD}Modernization Readiness Assessment{NC}")
+print()
+print(f"  Codebase:  {report['codebase']}")
+print(f"  Files:     {total_files} source file(s)")
+print(f"  LOC:       {total_loc}")
+if total_files == 0:
+    print()
+    print("  No recognized source files found; nothing to assess.")
+    sys.exit(0)
+print()
+print(f"{BOLD}Language mix{NC}")
+for lm in lang_mix:
+    print(f"  {lm['language']:<12} {lm['loc']:>8} LOC  ({lm['pct']}%, {lm['files']} files)")
+print()
+print(f"{BOLD}Technical-debt signals{NC}")
+d = report['debt_signals']
+print(f"  Tests present:       {'yes' if d['has_tests'] else 'NO'} "
+      f"({d['test_files']} test file(s), {d['test_ratio']:.0%} of files)")
+print(f"  TODO/FIXME/HACK:     {d['todo_fixme_count']} "
+      f"({d['todo_density_per_kloc']} per KLOC)")
+print(f"  Large files (>=500): {d['large_files_ge_500_loc']} "
+      f"(largest {d['largest_file_loc']} LOC)")
+mr = report['maintenance_risk']
+lock_str = ('yes' if mr['dependency_lock_present'] else 'NO') if mr['dependency_lock_present'] is not None else 'no manifest'
+print(f"  Dependency lockfile: {lock_str}")
+print(f"  Dependency staleness: {mr['dependency_staleness']} (not computed offline)")
+print()
+print(f"{BOLD}Maturity{NC} (Ad hoc -> Planned -> Systematic -> Optimized)")
+print(f"  Level {maturity_level}/4: {CYAN}{maturity}{NC}")
+print(f"  {maturity_reason}")
+print()
+print(f"{BOLD}Where to start{NC} (ranked low-blast-radius, high-visibility targets)")
+if not top:
+    print("  No non-test candidate modules found.")
+else:
+    for i, f in enumerate(top, 1):
+        print(f"  {i}. {f['path']}")
+        print(f"     {target_rationale(f)}")
+print()
+PYASSESS
+        return $?
+    fi
+
     if [ "$do_report" = "true" ]; then
         local heal_dir="${codebase_path:-.}/.loki/healing"
         if [[ ! -d "$heal_dir" ]]; then

package/autonomy/run.sh

@@ -1668,7 +1668,7 @@ _loki_trust_run_id() {
 # Args: $1 = the new phase value (REASONING, BUILDING, VERIFYING, COMPLETED, etc.)
 _advance_current_phase() {
     local new_phase="${1:?phase required}"
-    local loki_dir="${LOKI_DIR:-${TARGET_DIR:-.}}/.loki"
+    local loki_dir="${LOKI_DIR:-${TARGET_DIR:-.}/.loki}"
     local orch="$loki_dir/state/orchestrator.json"
     [ -f "$orch" ] || return 0
     # Values are passed via argv (not interpolated into the source) so a phase or
@@ -8965,6 +8965,71 @@ except Exception:
     return 0
 }
 
+# _loki_zero_tests_executed -- shared "no real tests ran" detector (#82).
+# A runner that exits 0 but executed ZERO actual tests is a mini fake-green: it
+# records pass while proving nothing. This inspects a runner's raw output and
+# returns 0 (true, "zero tests executed") ONLY on positive detection; any
+# unrecognized/unparseable shape returns 1 (false) so a legitimate suite this
+# helper cannot parse is NEVER false-downgraded (bounded blast radius).
+#
+#   $1 = runner label (node-test|jest|vitest|...)
+#   $2 = raw runner output
+#   $3.. = (optional) test-file paths that were passed to node --test; their
+#          basenames are node's file-wrapper subtest labels and must be excluded
+#          from the "real test" count.
+#
+# node --test: even a *.test.js with NO test() calls emits `# tests 1 # pass 1`
+#   because node counts the FILE ITSELF as one passing pseudo-test, printed as
+#   `ok N - <file-basename>`. So `# tests 0` NEVER fires (verified on Node 22).
+#   The true executed count = ok/not-ok lines whose label is NOT a passed file
+#   basename. Zero such lines + exit 0 = no real tests ran.
+# jest --passWithNoTests: prints "No tests found" and NO "Tests:" summary line.
+_loki_zero_tests_executed() {
+    local _zt_runner="$1"; shift
+    local _zt_out="$1"; shift
+    case "$_zt_runner" in
+        node-test)
+            # node's file-wrapper subtest label is the ARGUMENT VERBATIM (the
+            # full path we passed), and separately its basename for older node.
+            # Register BOTH forms so the wrapper line is excluded either way.
+            # Delimited with newlines so a path containing spaces still matches
+            # exactly (space-delimited would split it).
+            local _zt_f _zt_bases=$'\n'
+            for _zt_f in "$@"; do
+                [ -n "$_zt_f" ] || continue
+                _zt_bases="${_zt_bases}${_zt_f}"$'\n'"$(basename "$_zt_f")"$'\n'
+            done
+            # Count ok/not-ok lines whose label is a REAL test (label not a
+            # file-wrapper). node prints "ok N - <label>" / "not ok N - <label>".
+            local _zt_real=0 _zt_line _zt_label
+            while IFS= read -r _zt_line; do
+                # Strip "ok N - " / "not ok N - " prefix to get the label.
+                _zt_label="${_zt_line#* - }"
+                # A file-wrapper label equals a passed file path or basename -> skip.
+                case "$_zt_bases" in
+                    *$'\n'"$_zt_label"$'\n'*) continue ;;
+                esac
+                _zt_real=$((_zt_real + 1))
+            done < <(printf '%s\n' "$_zt_out" | grep -E '^(ok|not ok) [0-9]+ - ' 2>/dev/null)
+            [ "$_zt_real" -eq 0 ] && return 0
+            return 1
+            ;;
+        jest|monorepo-jest)
+            # jest --passWithNoTests: "No tests found, exiting with code 0" and no
+            # "Tests:" summary. A real run prints "Tests: N passed, ...".
+            if printf '%s' "$_zt_out" | grep -qiE 'no tests found' 2>/dev/null \
+               && ! printf '%s' "$_zt_out" | grep -qE '^Tests:' 2>/dev/null; then
+                return 0
+            fi
+            return 1
+            ;;
+        *)
+            # Unknown/unparseable runner -> never claim zero-tests (safe default).
+            return 1
+            ;;
+    esac
+}
+
 enforce_test_coverage() {
     local loki_dir="${TARGET_DIR:-.}/.loki"
     local quality_dir="$loki_dir/quality"
@@ -9159,6 +9224,51 @@ sys.stdout.write(t.strip())
         details="cargo test: $(echo "$output" | tail -3 | tr '\n' ' ')"
     fi
 
+    # node --test (built-in Node test runner) -- config-less fallback (task #79).
+    # Node's built-in runner (stable since Node 18) runs *.test.{js,mjs,cjs}
+    # with ZERO config and NO package.json. A deliverable of slug.js +
+    # slug.test.js (a real, passing suite) previously fell straight through to
+    # runner="none" and recorded verification_gap="source_without_tests" -- a
+    # FALSE-NEGATIVE trust defect (symmetric to fake-green): genuinely-correct,
+    # fully-tested work read as NOT VERIFIED. This branch fires ONLY as a
+    # fallback below every explicit-framework path (vitest/jest/mocha/scripts.test
+    # via package.json, monorepo, pytest, go, cargo all gate on
+    # test_runner=="none"), so package.json-with-jest still selects jest. It runs
+    # only when node is on PATH AND *.test.{js,mjs,cjs} files exist at root or
+    # under test/ or tests/. A failing suite records test_passed=false (never
+    # swallowed); absence of node or test files falls through to the honest
+    # "none"/inconclusive path below (never fabricates a pass).
+    if [ "$test_runner" = "none" ] && command -v node &>/dev/null; then
+        local _nt_files=()
+        local _nt_f
+        # Root-level test files (maxdepth 1) plus test/ and tests/ dirs, skipping
+        # vendored trees so we never walk node_modules.
+        while IFS= read -r _nt_f; do
+            [ -n "$_nt_f" ] && _nt_files+=("$_nt_f")
+        done < <(find "${TARGET_DIR:-.}" -maxdepth 1 -type f \
+                    \( -name '*.test.js' -o -name '*.test.mjs' -o -name '*.test.cjs' \) \
+                    2>/dev/null)
+        for _nt_dir in test tests; do
+            [ -d "${TARGET_DIR:-.}/$_nt_dir" ] || continue
+            while IFS= read -r _nt_f; do
+                [ -n "$_nt_f" ] && _nt_files+=("$_nt_f")
+            done < <(find "${TARGET_DIR:-.}/$_nt_dir" -maxdepth 3 -type f \
+                        \( -name '*.test.js' -o -name '*.test.mjs' -o -name '*.test.cjs' \) \
+                        -not -path '*/node_modules/*' 2>/dev/null)
+        done
+        if [ "${#_nt_files[@]}" -gt 0 ]; then
+            test_runner="node-test"
+            local output
+            # Pass matched files explicitly (node --test globbing is
+            # Node-version-sensitive); quote each so paths with spaces survive.
+            output=$(cd "${TARGET_DIR:-.}" && timeout "${LOKI_GATE_TIMEOUT:-300}" \
+                         node --test "${_nt_files[@]}" 2>&1) || test_passed=false
+            # tail -14 so node's TAP summary block (# tests / # pass N / # fail N,
+            # ~10 lines) survives truncation for the best-effort count parse below.
+            details="node --test: $(echo "$output" | tail -14 | tr '\n' ' ')"
+        fi
+    fi
+
     if [ "$test_runner" = "none" ]; then
         log_info "Test coverage: no test runner detected, recording inconclusive (not pass)"
         # v7.41.x fail-open fix: previously this wrote pass:true, so a project
@@ -9254,18 +9364,51 @@ TREOF
         *)           _tr_cmd="$test_runner" ;;
     esac
     if [ "$test_passed" = "true" ]; then _tr_exit=0; _tr_status="verified"; else _tr_exit=1; _tr_status="failed"; fi
+
+    # #82 (zero-test-file hardening): a runner that EXITED 0 but executed ZERO
+    # real tests is a mini fake-green -- it records "verified" while proving
+    # nothing. node --test on a *.test.js with no test() calls exits 0 (node
+    # counts the FILE ITSELF as one passing pseudo-test, so `# tests 0` never
+    # fires); jest --passWithNoTests exits 0 on an empty suite. Detect the
+    # zero-real-test case ONLY on a green run (a red run already records fail
+    # and must stay fail), and downgrade the record from affirmative to an
+    # HONEST inconclusive (status=no_tests_run, gap=source_without_runnable_tests,
+    # pass:"inconclusive"). This is NOT a failure: the completion-council
+    # evidence gate treats it as pass-through, exactly like runner=="none".
+    # Positive-detection only -- an unparseable runner is left UNCHANGED
+    # (pass:true) so a legitimate suite is never false-downgraded.
+    local _tr_zero_tests=false
+    if [ "$test_passed" = "true" ] \
+       && _loki_zero_tests_executed "$test_runner" "${output:-}" "${_nt_files[@]:-}"; then
+        _tr_zero_tests=true
+        _tr_status="no_tests_run"
+        log_warn "Verification gap: $test_runner exited 0 but ran ZERO tests -- recording inconclusive (no_tests_run), not verified"
+    fi
+
     # Best-effort pass/fail counts from the summary text (null when not found).
     local _tr_passed_n _tr_failed_n
     _tr_passed_n=$(printf '%s' "$details" | grep -oE '[0-9]+ passed' | grep -oE '[0-9]+' | head -1)
     _tr_failed_n=$(printf '%s' "$details" | grep -oE '[0-9]+ failed' | grep -oE '[0-9]+' | head -1)
+    # node --test emits TAP-ish "# pass N" / "# fail N" summary lines, which the
+    # "N passed"/"N failed" pattern above does not match. Fall back to those.
+    [ -n "$_tr_passed_n" ] || _tr_passed_n=$(printf '%s' "$details" | grep -oE '# pass [0-9]+' | grep -oE '[0-9]+' | head -1)
+    [ -n "$_tr_failed_n" ] || _tr_failed_n=$(printf '%s' "$details" | grep -oE '# fail [0-9]+' | grep -oE '[0-9]+' | head -1)
     [ -n "$_tr_passed_n" ] || _tr_passed_n=null
     [ -n "$_tr_failed_n" ] || _tr_failed_n=null
 
-    # verification_gap is "none" whenever a real runner executed: the suite ran,
-    # so there is no docs-without-execution / source-without-tests gap. Keeping
-    # the key on BOTH writers gives consumers a single stable schema shape.
+    # verification_gap is "none" whenever a real runner executed AND ran tests:
+    # the suite ran, so there is no docs-without-execution / source-without-tests
+    # gap. The #82 zero-test case is the exception -- a runner ran but executed
+    # NO tests -- so it records pass:"inconclusive" (the string, distinct from the
+    # bool true/false) + gap:source_without_runnable_tests. Keeping the key on
+    # BOTH writers gives consumers a single stable schema shape.
+    local _tr_pass_json="$test_passed" _tr_gap_json="none"
+    if [ "$_tr_zero_tests" = "true" ]; then
+        _tr_pass_json='"inconclusive"'
+        _tr_gap_json="source_without_runnable_tests"
+    fi
     cat > "$quality_dir/test-results.json" << TREOF
-{"timestamp":"$(date -u +%Y-%m-%dT%H:%M:%SZ)","runner":"$test_runner","pass":$test_passed,"min_coverage":$min_coverage,"summary":"$details","command":"$_tr_cmd","exit_code":$_tr_exit,"status":"$_tr_status","passed_count":$_tr_passed_n,"failed_count":$_tr_failed_n,"verification_gap":"none"}
+{"timestamp":"$(date -u +%Y-%m-%dT%H:%M:%SZ)","runner":"$test_runner","pass":$_tr_pass_json,"min_coverage":$min_coverage,"summary":"$details","command":"$_tr_cmd","exit_code":$_tr_exit,"status":"$_tr_status","passed_count":$_tr_passed_n,"failed_count":$_tr_failed_n,"verification_gap":"$_tr_gap_json"}
 TREOF
     # Finding #598: stamp the per-iteration freshness marker (see above).
     printf '%s\n' "${ITERATION_COUNT:-0}" > "$quality_dir/.test-results.iter" 2>/dev/null || true
@@ -19316,7 +19459,7 @@ main() {
     # engine's own is_completed() recognise this session as terminal. Write the
     # file-system COMPLETED marker (checked by is_completed() in the main loop).
     _advance_current_phase "COMPLETED"
-    local loki_dir="${LOKI_DIR:-${TARGET_DIR:-.}}/.loki"
+    local loki_dir="${LOKI_DIR:-${TARGET_DIR:-.}/.loki}"
     echo "Session completed at $(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$loki_dir/COMPLETED" 2>/dev/null || true
 
     # Finish-and-own (v7.88.0): write a plain-English ownership handoff

package/autonomy/verify.sh

@@ -292,6 +292,54 @@ verify_gate_build() {
     return 0
 }
 
+# _verify_zero_tests_executed -- "no real tests ran" detector (#82), mirrors
+# _loki_zero_tests_executed in run.sh. Returns 0 (true) ONLY on positive
+# detection of a runner that exited 0 yet executed ZERO actual tests; any
+# unrecognized shape returns 1 (false) so a legitimate suite is never
+# false-downgraded.  $1=runner  $2=raw output  $3..=node --test file paths.
+#
+# node --test: a *.test.js with no test() calls still emits `# tests 1 # pass 1`
+#   (node counts the FILE as one passing pseudo-test: `ok N - <file-basename>`),
+#   so the true executed count = ok/not-ok lines whose label is NOT a passed
+#   file basename. Zero such = no real tests.
+# jest --passWithNoTests: prints "No tests found" and no "Tests:" summary.
+_verify_zero_tests_executed() {
+    local _zt_runner="$1"; shift
+    local _zt_out="$1"; shift
+    case "$_zt_runner" in
+        node-test)
+            # node's file-wrapper label is the argument verbatim (full path) and,
+            # on older node, its basename. Register BOTH (newline-delimited so a
+            # spaced path still matches exactly).
+            local _zt_f _zt_bases=$'\n'
+            for _zt_f in "$@"; do
+                [ -n "$_zt_f" ] || continue
+                _zt_bases="${_zt_bases}${_zt_f}"$'\n'"$(basename "$_zt_f")"$'\n'
+            done
+            local _zt_real=0 _zt_line _zt_label
+            while IFS= read -r _zt_line; do
+                _zt_label="${_zt_line#* - }"
+                case "$_zt_bases" in
+                    *$'\n'"$_zt_label"$'\n'*) continue ;;
+                esac
+                _zt_real=$((_zt_real + 1))
+            done < <(printf '%s\n' "$_zt_out" | grep -E '^(ok|not ok) [0-9]+ - ' 2>/dev/null)
+            [ "$_zt_real" -eq 0 ] && return 0
+            return 1
+            ;;
+        jest)
+            if printf '%s' "$_zt_out" | grep -qiE 'no tests found' 2>/dev/null \
+               && ! printf '%s' "$_zt_out" | grep -qE '^Tests:' 2>/dev/null; then
+                return 0
+            fi
+            return 1
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
 # ---------------------------------------------------------------------------
 # Gate: tests (faithful port of enforce_test_coverage detection, run.sh:6624).
 #
@@ -301,7 +349,9 @@ verify_gate_build() {
 # skipped  = no test framework detected at all (not-applicable).
 # inconclusive = a project is present but no runnable framework
 #                (e.g. package.json with no test runner, or a python project
-#                 with no pytest on PATH). Forces at-least-CONCERNS.
+#                 with no pytest on PATH), OR a runner that ran but executed
+#                 ZERO tests (#82: node --test empty file, jest --passWithNoTests).
+#                Forces at-least-CONCERNS.
 # fail     = tests ran and failed -> High finding.
 # pass     = tests ran green.
 # ---------------------------------------------------------------------------
@@ -383,6 +433,41 @@ verify_gate_tests() {
         fi
     fi
 
+    # node --test (built-in Node runner) -- config-less fallback (task #79).
+    # Node's built-in test runner (stable since Node 18) runs
+    # *.test.{js,mjs,cjs} with ZERO config and NO package.json, so a real
+    # passing suite (slug.js + slug.test.js, no package.json) previously fell
+    # through to runner="none" -> tests "skipped" -- a FALSE-NEGATIVE on the
+    # verdict surface (symmetric to fake-green). This branch fires ONLY below
+    # the explicit-framework paths (vitest/jest/mocha via package.json all set
+    # runner above), so package.json-with-jest still selects jest. Runs only
+    # when node is on PATH AND *.test.{js,mjs,cjs} exist at root or under
+    # test/ or tests/. A FAILING run records fail (never swallowed); absence of
+    # node or test files falls through to the honest "skipped" path below.
+    if [ "$runner" = "none" ] && command -v node >/dev/null 2>&1; then
+        local _nt_files=()
+        local _nt_f _nt_dir
+        while IFS= read -r _nt_f; do
+            [ -n "$_nt_f" ] && _nt_files+=("$_nt_f")
+        done < <(find "$tree" -maxdepth 1 -type f \
+                    \( -name '*.test.js' -o -name '*.test.mjs' -o -name '*.test.cjs' \) \
+                    2>/dev/null)
+        for _nt_dir in test tests; do
+            [ -d "$tree/$_nt_dir" ] || continue
+            while IFS= read -r _nt_f; do
+                [ -n "$_nt_f" ] && _nt_files+=("$_nt_f")
+            done < <(find "$tree/$_nt_dir" -maxdepth 3 -type f \
+                        \( -name '*.test.js' -o -name '*.test.mjs' -o -name '*.test.cjs' \) \
+                        -not -path '*/node_modules/*' 2>/dev/null)
+        done
+        if [ "${#_nt_files[@]}" -gt 0 ]; then
+            runner="node-test"
+            # Pass matched files explicitly (node --test globbing is
+            # Node-version-sensitive); quote each so paths with spaces survive.
+            out="$(cd "$tree" && timeout "$timeout_s" node --test "${_nt_files[@]}" 2>&1)" || rc=$?
+        fi
+    fi
+
     if [ "$runner" = "none" ]; then
         _verify_add_gate "tests" "skipped" "" "no test framework detected" "true"
         return 0
@@ -394,7 +479,15 @@ verify_gate_tests() {
     fi
 
     if [ "$rc" -eq 0 ]; then
-        _verify_add_gate "tests" "pass" "$runner" "tests passed" "true"
+        # #82: a green run that executed ZERO real tests is a mini fake-green.
+        # Record it as HONEST inconclusive (forces at-least-CONCERNS), NOT pass
+        # and NOT fail. Positive-detection only; an unparseable runner stays pass.
+        if _verify_zero_tests_executed "$runner" "$out" "${_nt_files[@]:-}"; then
+            _verify_add_gate "tests" "inconclusive" "$runner" \
+                "runner ran but executed zero tests (source_without_runnable_tests)" "true"
+        else
+            _verify_add_gate "tests" "pass" "$runner" "tests passed" "true"
+        fi
     else
         _verify_add_gate "tests" "fail" "$runner" "tests failed (rc=$rc)" "true"
         _verify_add_finding "High" "tests" "deterministic:$runner" "" "null" \

package/dashboard/__init__.py

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

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Loki Mode is a spec-driven autonomous builder with a built-in trust layer that takes any spec to a deployed product and verifies completion with evidence (quality gates plus a completion council), not just a "done" claim. Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.115.0
+**Version:** v7.117.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.115.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.117.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=7679240CF905E39B64756E2164756E21
+//# debugId=54117DFE71A29F8B64756E2164756E21

package/mcp/__init__.py

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

package/package.json

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