loki-mode 7.116.0 → 7.117.1

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.116.0
+# Loki Mode v7.117.1
 
 **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.116.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.117.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.116.0
+7.117.1

package/autonomy/completion-council.sh

@@ -1753,7 +1753,7 @@ council_evidence_gate() {
     local test_inconclusive_reason=""
     if [ -f "$tr_file" ]; then
         local test_status
-        test_status=$(_TR_FILE="$tr_file" python3 -c "
+        test_status=$(_TR_FILE="$tr_file" python3 <<'PYEOF' 2>/dev/null || echo "INCONCLUSIVE:none:true"
 import json, os, sys
 tr_file = os.environ['_TR_FILE']
 try:
@@ -1764,13 +1764,25 @@ 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")
+PYEOF
+)
         local _verdict="${test_status%%:*}"
         local _rest="${test_status#*:}"
         test_runner="${_rest%%:*}"
@@ -1787,6 +1799,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

@@ -1382,8 +1382,14 @@ _parse_json_field() {
     if command -v python3 >/dev/null 2>&1; then
         python3 -c "import json,sys; print(json.load(open(sys.argv[1])).get(sys.argv[2],''))" "$file" "$field" 2>/dev/null
     else
-        # Shell fallback: extract value for simple flat JSON
-        sed 's/.*"'"$field"'":\s*//' "$file" 2>/dev/null | sed 's/[",}].*//' | head -1
+        # Shell fallback (no python3): extract value for simple flat JSON. Handles
+        # BOTH quoted string values ("kind":"wrapper") and bare numeric values
+        # ("ppid":206). The prior impl stripped the leading quote's content to empty
+        # for string fields -- broke "kind" parsing on python3-less hosts, which
+        # would drop wrapper entries into the legacy child path (loki-mode #92).
+        sed 's/.*"'"$field"'":[[:space:]]*//' "$file" 2>/dev/null \
+            | sed 's/^"//' \
+            | sed 's/[",}].*//' | head -1
     fi
 }
 
@@ -1435,6 +1441,93 @@ kill_registered_pid() {
     unregister_pid "$pid"
 }
 
+# Register the CURRENTLY-RUNNING loki-run wrapper itself in the registry.
+# The wrapper registers its children but historically never itself, so a wrapper
+# whose launching session dies is never reaped (loki-mode #92). We record the
+# LAUNCHER's mortal pid (NOT $$ -- $$ is the wrapper's own pid, which would make
+# the parent-death check always succeed and the reaper INERT; NOT $PPID either --
+# in the detached setsid/nohup path bash caches getppid()==1 at exec, and kill -0 1
+# is always true -> also inert). The launcher exports LOKI_LAUNCHER_PID=$$ at each
+# backgrounding site; that launcher shell exits immediately after backgrounding, so
+# the recorded ppid genuinely dies and the parent-death precondition CAN fire. For
+# the foreground path LOKI_LAUNCHER_PID is unset -> $PPID (the user's shell) is the
+# correct mortal fallback. Reap-vs-spare is then decided by the LIVENESS predicate,
+# not by parentage alone. Uses a "kind":"wrapper" tag so cleanup_orphan_pids routes
+# only wrapper entries through the predicate and keeps child entries byte-identical.
+register_self_wrapper() {
+    [ -z "$PID_REGISTRY_DIR" ] && init_pid_registry
+    local launcher_ppid="${LOKI_LAUNCHER_PID:-$PPID}"
+    case "$launcher_ppid" in ''|*[!0-9]*) launcher_ppid="$PPID" ;; esac
+    local entry_file="$PID_REGISTRY_DIR/$$.json"
+    cat > "$entry_file" << EOF
+{"pid":$$,"label":"loki-wrapper","started":"$(date -u +%Y-%m-%dT%H:%M:%SZ)","ppid":$launcher_ppid,"kind":"wrapper","extra":""}
+EOF
+}
+
+# Pure, side-effect-free reap predicate (loki-mode #92). ALL inputs are
+# pre-computed scalars (0/1 booleans or integer ms); NO stat/kill/pgrep inside so
+# it is hermetically unit-testable. Prints "1" (reap) or "0" (spare); returns 0.
+# Reap ONLY when: parent dead AND no live engine child AND idle past the budget.
+# Mirrors the SaaS BFF sweepStuckBuilds and the #91 worker "no-activity != dead"
+# symmetry: a genuinely-detached run that keeps writing .loki activity is spared.
+#   parent_alive:     1 if recorded ppid is still alive, else 0
+#   last_activity_ms: epoch-ms of most recent .loki activity (0 if none found)
+#   now_ms:           current epoch-ms
+#   idle_budget_ms:   generous idle budget (default 900000 = 15 min)
+#   has_live_child:   1 if wrapper has a live ENGINE child (claude/node), else 0
+shouldReapOrphan() {
+    local parent_alive="$1" last_activity_ms="$2" now_ms="$3" idle_budget_ms="$4" has_live_child="$5"
+    if [ "$parent_alive" = "0" ] && [ "$has_live_child" = "0" ] \
+       && [ $(( now_ms - last_activity_ms )) -ge "$idle_budget_ms" ]; then
+        echo 1
+    else
+        echo 0
+    fi
+}
+
+# Most-recent .loki activity as epoch-ms across events.jsonl, signals/*,
+# autonomy-state.json. Cross-platform stat (macOS -f %m / Linux -c %Y). On a stat
+# PARSE FAILURE we default to now_ms (SPARE), never 0 -- a wrong flag must not make a
+# live run look maximally idle and get reaped. "No activity files exist" legitimately
+# yields 0 (reap-eligible); that is distinct from a stat error.
+_loki_last_activity_ms() {
+    local loki_dir="${TARGET_DIR:-.}/.loki"
+    local newest=0 f mt stat_ok=0
+    local candidates=()
+    [ -f "$loki_dir/events.jsonl" ] && candidates+=("$loki_dir/events.jsonl")
+    [ -f "$loki_dir/autonomy-state.json" ] && candidates+=("$loki_dir/autonomy-state.json")
+    if [ -d "$loki_dir/signals" ]; then
+        for f in "$loki_dir/signals"/*; do [ -e "$f" ] && candidates+=("$f"); done
+    fi
+    for f in "${candidates[@]:-}"; do
+        [ -e "$f" ] || continue
+        mt=$(stat -f %m "$f" 2>/dev/null) || mt=""
+        [ -z "$mt" ] && { mt=$(stat -c %Y "$f" 2>/dev/null) || mt=""; }
+        case "$mt" in ''|*[!0-9]*) continue ;; esac
+        stat_ok=1
+        [ "$mt" -gt "$newest" ] && newest="$mt"
+    done
+    # candidates present but every stat failed -> parse failure -> spare (now_ms)
+    if [ "${#candidates[@]}" -gt 0 ] && [ "$stat_ok" = "0" ]; then
+        echo "$(( $(date +%s) * 1000 ))"
+        return 0
+    fi
+    echo "$(( newest * 1000 ))"
+}
+
+# Count LIVE ENGINE children of a wrapper (claude/node), EXCLUDING sleep and the
+# status/resource monitors. The observed 3h orphan had only sleep children, so a
+# naive `pgrep -P` (any child) would falsely spare it; the comm filter is what makes
+# the reaper actually fire on the real orphan shape. Prints 1 (has engine child) or 0.
+_loki_has_live_engine_child() {
+    local wrapper_pid="$1" c cc
+    for c in $(pgrep -P "$wrapper_pid" 2>/dev/null); do
+        cc=$(ps -o comm= -p "$c" 2>/dev/null)
+        case "$cc" in *claude*|*node*) echo 1; return 0 ;; esac
+    done
+    echo 0
+}
+
 # Scan registry for orphaned processes and kill them
 # Called on startup and by `loki cleanup`
 # Returns: number of orphans killed
@@ -1457,6 +1550,9 @@ cleanup_orphan_pids() {
             ''|*[!0-9]*) continue ;;
         esac
 
+        # Never reap the currently-running wrapper itself (loki-mode #92 self-skip).
+        [ "$pid" = "$$" ] && continue
+
         if kill -0 "$pid" 2>/dev/null; then
             # Process is alive -- check if its parent session is dead
             local ppid_val=""
@@ -1464,7 +1560,30 @@ cleanup_orphan_pids() {
 
             # Validate ppid_val is numeric before using with kill
             case "$ppid_val" in ''|*[!0-9]*) ppid_val="" ;; esac
-            if [ -n "$ppid_val" ] && [ "$ppid_val" != "$$" ]; then
+
+            # Route WRAPPER entries through the liveness predicate; CHILD entries
+            # (no "kind" field) keep the exact parent-death-only behavior (#92).
+            local kind=""
+            kind=$(_parse_json_field "$entry_file" "kind") || true
+
+            if [ "$kind" = "wrapper" ]; then
+                # Wrapper: reap only if orphaned AND idle-past-budget AND no live
+                # engine child. Compute the impure inputs here (predicate stays pure).
+                if [ -n "$ppid_val" ]; then
+                    local parent_alive=0
+                    kill -0 "$ppid_val" 2>/dev/null && parent_alive=1
+                    local last_activity_ms now_ms has_live_child idle_budget_ms
+                    last_activity_ms=$(_loki_last_activity_ms)
+                    now_ms=$(( $(date +%s) * 1000 ))
+                    has_live_child=$(_loki_has_live_engine_child "$pid")
+                    idle_budget_ms="${LOKI_WRAPPER_IDLE_BUDGET_MS:-900000}"
+                    if [ "$(shouldReapOrphan "$parent_alive" "$last_activity_ms" "$now_ms" "$idle_budget_ms" "$has_live_child")" = "1" ]; then
+                        log_warn "Reaping idle orphaned loki wrapper PID=$pid (parent $ppid_val dead, idle >=$((idle_budget_ms/60000))m, no engine child)" >&2
+                        kill_registered_pid "$pid"
+                        orphan_count=$((orphan_count + 1))
+                    fi
+                fi
+            elif [ -n "$ppid_val" ] && [ "$ppid_val" != "$$" ]; then
                 if ! kill -0 "$ppid_val" 2>/dev/null; then
                     # Parent is dead -- this is an orphan
                     local label=""
@@ -1498,6 +1617,9 @@ kill_all_registered() {
         case "$pid" in
             ''|*[!0-9]*) continue ;;
         esac
+        # Never SIGKILL the running wrapper itself mid-shutdown (loki-mode #92):
+        # it now self-registers, so it would otherwise appear in this sweep.
+        [ "$pid" = "$$" ] && continue
         kill_registered_pid "$pid"
     done
 }
@@ -8965,6 +9087,86 @@ 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
+            ;;
+        go-test)
+            # #89: `go test ./...` on a package with NO *_test.go EXITS 0 and prints
+            # `?   <pkg>  [no test files]` -- so a Go project with source but no
+            # tests would score `pass` (a mini fake-green; unlike vitest/pytest/
+            # mocha which exit NON-zero on zero tests and are already not-pass, so
+            # go-test is the only runner in this class that needs detection).
+            # POSITIVE detection: a `[no test files]` line AND no ran-package result
+            # (`ok `/`FAIL`). A mixed run (some pkgs tested) has `ok`, so it is NOT
+            # downgraded. Verified: real passing prints `ok  <pkg>  0.2s`.
+            if printf '%s' "$_zt_out" | grep -qE '\[no test files\]' 2>/dev/null \
+               && ! printf '%s' "$_zt_out" | grep -qE '^(ok|FAIL|--- FAIL)' 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"
@@ -9299,6 +9501,27 @@ 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)
@@ -9310,11 +9533,19 @@ TREOF
     [ -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
@@ -16077,6 +16308,47 @@ except Exception:
         if type spec_interrogation_run &>/dev/null; then
             spec_interrogation_run "$prd_path" || true
         fi
+        # #87: no-HITL fast-fail on an unresolved spec-INTERNAL contradiction.
+        # A contradiction (class=contradictory) is NEVER auto-acked (P2-4) and only
+        # a human sets confirmed=true, so in an AUTONOMOUS run it can never clear ->
+        # the completion gate blocks EVERY iteration -> the loop grinds to
+        # max-iterations (~20min, opaque). This run is already doomed; here we fail
+        # FAST + HONEST + NAMED instead. Honesty: this is the no-HITL rule verbatim
+        # ("when unsafe to decide, inconclusive-and-proceed, never fake-green") --
+        # it NEVER declares done/green (inconclusive_spec_contradiction maps to a
+        # terminal-failure exit, tested), it just replaces the opaque grind.
+        # SCOPE (deliberately narrow, no regression): fires ONLY when
+        #   (a) non-interactive/no-HITL (a TTY human COULD resolve it -> let them), AND
+        #   (b) LOKI_ASSUMPTIONS_REQUIRE_CONFIRM != 1 (that knob means a human WILL
+        #       confirm -> do not pre-empt), AND
+        #   (c) there is >=1 UNRESOLVED class=contradictory entry (the contradiction-
+        #       specific count, NOT the broader high-unresolved which includes
+        #       auto-ackable non-contradictions).
+        # Opt-out: LOKI_SPEC_CONTRADICTION_FASTFAIL=0.
+        if [ "${LOKI_SPEC_CONTRADICTION_FASTFAIL:-1}" = "1" ] \
+           && [ ! -t 0 ] \
+           && [ "${LOKI_ASSUMPTIONS_REQUIRE_CONFIRM:-0}" != "1" ] \
+           && type spec_ledger_contradiction_unresolved_count &>/dev/null; then
+            _sc_out="$(spec_ledger_contradiction_unresolved_count 2>/dev/null)"
+            _sc_n="$(printf '%s' "$_sc_out" | head -1)"
+            case "$_sc_n" in ''|*[!0-9]*) _sc_n=0 ;; esac
+            if [ "$_sc_n" -ge 1 ]; then
+                # Option C: name the contradicting clauses so `loki why` is actionable.
+                local _sc_titles
+                _sc_titles="$(printf '%s' "$_sc_out" | tail -n +2 | sed 's/^/  - /' | head -5)"
+                log_error "Spec has ${_sc_n} unresolved internal contradiction(s); an autonomous run cannot resolve them (only a human can). Failing fast instead of grinding to max-iterations."
+                [ -n "$_sc_titles" ] && printf '%s\n' "$_sc_titles" >&2
+                if type _loki_write_last_error &>/dev/null; then
+                    _loki_write_last_error 0 "spec_contradiction" \
+                        "Spec is internally inconsistent (${_sc_n} unresolved contradiction(s)); resolve the conflicting requirements, then re-run."
+                fi
+                save_state "$retry" "inconclusive_spec_contradiction" 0
+                if type emit_completion_summary &>/dev/null; then
+                    emit_completion_summary inconclusive_spec_contradiction 2>/dev/null || true
+                fi
+                return 20
+            fi
+        fi
     fi
 
     # Auto-derive completion promise from PRD (v6.10.0)
@@ -18945,13 +19217,13 @@ main() {
         # pgid.
         case "$_sess_launcher" in
             setsid)
-                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 nohup setsid "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
+                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 LOKI_LAUNCHER_PID=$$ nohup setsid "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
             perl-setsid)
-                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 nohup perl -e 'use POSIX qw(setsid); setsid(); exec @ARGV or exit 127;' "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
+                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 LOKI_LAUNCHER_PID=$$ nohup perl -e 'use POSIX qw(setsid); setsid(); exec @ARGV or exit 127;' "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
             python-setsid)
-                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 nohup python3 -c 'import os,sys; os.setsid(); os.execvp(sys.argv[1], sys.argv[1:])' "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
+                LOKI_RUNNING_FROM_TEMP='' LOKI_OWN_SESSION=1 LOKI_LAUNCHER_PID=$$ nohup python3 -c 'import os,sys; os.setsid(); os.execvp(sys.argv[1], sys.argv[1:])' "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
             *)
-                LOKI_RUNNING_FROM_TEMP='' nohup "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
+                LOKI_RUNNING_FROM_TEMP='' LOKI_LAUNCHER_PID=$$ nohup "$original_script" "${cmd_args[@]}" > "$log_file" 2>&1 & ;;
         esac
         local bg_pid=$!
         echo "$bg_pid" > "$pid_file"
@@ -19130,8 +19402,11 @@ main() {
         echo "${LOKI_SESSION_ID}" > ".loki/sessions/${LOKI_SESSION_ID}/session_id"
     fi
 
-    # Initialize PID registry and clean up orphans from previous sessions
+    # Initialize PID registry, self-register this wrapper (loki-mode #92 -- so a
+    # future session can reap it if this run is orphaned+idle), then clean up
+    # orphans from previous sessions.
     init_pid_registry
+    register_self_wrapper
     local orphan_count
     orphan_count=$(cleanup_orphan_pids)
     if [ "$orphan_count" -gt 0 ]; then
@@ -19458,7 +19733,7 @@ main() {
         case "$_final_status" in
             council_approved|council_force_approved|completion_promise_fulfilled|force_stopped|paused|interrupted|budget_exceeded|stopped)
                 result=0 ;;
-            failed|max_iterations_reached|max_retries_exceeded|policy_blocked)
+            failed|max_iterations_reached|max_retries_exceeded|policy_blocked|inconclusive_spec_contradiction)
                 result=20 ;;
             *)
                 # Unknown/running/exited terminal: leave $result as-is (nonzero on a

package/autonomy/spec-interrogation.sh

@@ -784,6 +784,44 @@ print(n)
 ' 2>/dev/null || printf '0'
 }
 
+# #87: the count of UNRESOLVED spec-INTERNAL CONTRADICTIONS (class=contradictory,
+# not confirmed, not acknowledged). This is the SUBSET of high-unresolved that can
+# NEVER clear in an autonomous run: contradictions are the only high entries that
+# spec_ledger_acknowledge_all deliberately refuses to auto-ack (P2-4), and only a
+# human sets confirmed=true. So >0 here means the completion gate will block every
+# iteration -> the run is ALREADY doomed to grind to max-iterations. run.sh uses
+# this at DISCOVERY to fail fast+honest (inconclusive_spec_contradiction) instead
+# of the opaque grind. Distinct from spec_ledger_high_unresolved_count (which
+# includes non-contradiction highs that CAN auto-ack and must NOT trigger fast-fail).
+# Also prints the contradicting assumption titles (one per line after the count)
+# so the terminal can NAME the cause (Option C).
+spec_ledger_contradiction_unresolved_count() {
+    local dir
+    dir="$(_spec_ledger_dir)"
+    if [ ! -d "$dir" ]; then printf '0'; return 0; fi
+    _SL_DIR="$dir" python3 -c '
+import glob, json, os
+d = os.environ["_SL_DIR"]
+n = 0
+titles = []
+for p in sorted(glob.glob(os.path.join(d, "a-*.json"))):
+    try:
+        with open(p) as f:
+            r = json.load(f)
+    except Exception:
+        continue
+    if (r.get("class") == "contradictory"
+            and not r.get("confirmed")
+            and not r.get("acknowledged")):
+        n += 1
+        t = r.get("title") or r.get("assumption") or r.get("finding") or "(unnamed contradiction)"
+        titles.append(str(t).replace("\n", " ")[:200])
+print(n)
+for t in titles:
+    print(t)
+' 2>/dev/null || printf '0'
+}
+
 # Total ledger entries + high count, "total high" on one line. For summaries.
 spec_ledger_counts() {
     local dir

package/autonomy/verify.sh

@@ -292,6 +292,70 @@ 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
+            ;;
+        go-test)
+            # #89: `go test ./...` on a package with NO *_test.go files prints
+            # `?   <pkg>  [no test files]` and EXITS 0 (unlike vitest/pytest/mocha,
+            # which exit non-zero on zero tests and are already caught as not-pass).
+            # So a Go project with source but no tests would score `pass` -- a mini
+            # fake-green. Detect it POSITIVELY: at least one `[no test files]` line
+            # AND ZERO package results that actually ran (`ok `/`FAIL`). A mixed
+            # run (some pkgs tested -> `ok`, others not -> `[no test files]`) has
+            # `ok` present, so it is NOT downgraded (verified: real passing prints
+            # `ok  <pkg>  0.2s`, a bare pkg prints `[no test files]`).
+            if printf '%s' "$_zt_out" | grep -qE '\[no test files\]' 2>/dev/null \
+               && ! printf '%s' "$_zt_out" | grep -qE '^(ok|FAIL|--- FAIL)' 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 +365,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.
 # ---------------------------------------------------------------------------
@@ -429,7 +495,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.116.0"
+__version__ = "7.117.1"
 
 # 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.116.0
+**Version:** v7.117.1
 
 ---
 

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.116.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.1";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=30F27BA7342E3CAE64756E2164756E21
+//# debugId=C0F83BD59DEB4E5764756E2164756E21

package/mcp/__init__.py

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

package/package.json

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