loki-mode 8.1.0 → 8.3.0

package/README.md

@@ -15,16 +15,102 @@ _The free, source-available autonomous coding agent by [Autonomi](https://www.au
 
 [Website](https://www.autonomi.dev/) | [Documentation](wiki/Home.md) | [Installation](docs/INSTALLATION.md) | [Changelog](CHANGELOG.md) | [Purple Lab -- deprecated v7.44.0](#purple-lab)
 
-**Current release: v8.0.0**
+**Current release: v8.3.0**
 
 </div>
 
 ---
 
+## See the receipt before you install anything
+
+Every agent claims it finished. Ours hands you an artifact you can check:
+
+```bash
+npx loki-mode tour     # no install, no API key, no spend, no network
+```
+
+That prints a real Evidence Receipt from a past build. Note what it says:
+
+```
+Headline: VERIFIED WITH GAPS
+
+| Fact          | Value                                    |
+| Files changed | 8                                        |
+| Diff sha256   | c2be6fff3e774c387f276277b25fc424f07b667… |
+| Tests         | verified (node-test)                     |
+| Build         | not_run                                  |
+| Security      | findings                                 |
+| Cost          | $10.3218                                 |
+```
+
+**"WITH GAPS" is the point.** Build was not run. Security has findings. The
+receipt says so on its own front page, and separates deterministic FACTS -- the
+diff hash, the test result, the cost -- from AI ASSESSMENTS, because only four
+of the eight quality gates are agent-independent and a receipt that implied
+otherwise would be marketing.
+
+Recompute the diff hash yourself and check it matches. That is the whole idea:
+you are not asked to trust the agent's self-report.
+
+Self-reported completion is the failure users actually hit. A survey of the
+open issue trackers of seven coding harnesses (OpenHands, Cline, Aider,
+SWE-agent, Roo-Code, OpenCode, Continue) found the recurring complaint is the
+agent silently not doing the work -- "always stuck at Preparing write"
+([opencode#11112](https://github.com/anomalyco/opencode/issues/11112), 76
+comments), "Continue not making changes to code"
+([continue#7143](https://github.com/continuedev/continue/issues/7143)), "Agent
+does not execute functions"
+([continue#5696](https://github.com/continuedev/continue/issues/5696)). None of
+those seven publishes a machine-checkable completion artifact.
+
+We have not audited the closed-source products (Cursor, Devin, Replit Agent)
+feature by feature, so treat this as "unclaimed as far as we can verify" rather
+than a proven first. The receipt stands on its own either way: run the tour and
+check the hash.
+
+**Evaluating this against something else?** [docs/EVALUATING.md](docs/EVALUATING.md)
+puts a runnable command next to every claim we make, and states plainly what we
+do not have (no enterprise case studies, no independent benchmark placement, and
+generation is not air-gapped). It ends with the one question worth asking any
+agent vendor, including us.
+
+---
+
 > **How it works:** Drop a spec -- a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief. Loki Mode classifies complexity (`run.sh:detect_complexity()`), assembles an agent team from 41 specialized agent roles across 8 domains - prompt-defined specifications the orchestrator adopts per phase, with parallel review (blind council) and optional worktree streams on Claude Code, sequential on other providers - and runs autonomous RARV cycles (Reason - Act - Reflect - Verify, see `run.sh:run_autonomous()`) with 8 quality gates (see `skills/quality-gates.md`). Code is not "done" until it passes automated verification. Output is a Git repo with source, tests, configs, and audit logs.
 
 ---
 
+## Already have a codebase? Start read-only.
+
+Most agents are built to create new apps. The harder, more valuable problem is
+the ten-year-old repo that pays the bills. Loki works on both, and on an
+existing codebase it starts by **changing nothing**:
+
+```bash
+loki modernize heal ./your-repo --assess          # read-only. no writes, no commits.
+loki modernize heal ./your-repo --assess --json   # same, machine-readable
+```
+
+You get a modernization readiness report: language mix, a 4-level maturity
+rating, technical-debt signals (test coverage, TODO density, oversized files,
+dependency staleness), and a **ranked list of where to start** -- ordered by
+blast radius, so the first change is the one least likely to break something.
+
+Then, if you want it to act:
+
+```bash
+loki modernize heal ./your-repo --strict          # block ALL behavioral change without approval
+loki modernize heal ./your-repo --phase archaeology   # extract knowledge only
+loki modernize heal ./your-repo --compliance healthcare   # or fintech | government
+```
+
+The healing pipeline runs in phases -- archaeology, stabilize, isolate,
+modernize, validate -- and the validate phase checks **behavioral equivalence
+against the pre-change baseline**, not just that the tests are green. Friction
+points (the weird code that exists for a reason nobody remembers) are cataloged
+before anything touches them, because in a legacy system the strange code is
+usually load-bearing.
+
 ## The Evidence Receipt: don't trust the agent, check it
 
 Every coding agent tells you it finished. Loki hands you something you can

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

package/VERSION

@@ -1 +1 @@
-8.1.0
+8.3.0

package/autonomy/completion-council.sh

@@ -2267,11 +2267,17 @@ PYEOF
         if [ -z "$_nm_cc_dir" ] || [ ! -f "$_nm_scanner" ]; then
             _nm_status="INCONCLUSIVE:scanner_unavailable"
         else
+            # STDIN, not an env var: a single env string is capped at
+            # MAX_ARG_STRLEN (131071 bytes) on Linux, so a large changed-file
+            # union makes execve fail with E2BIG and this gate silently
+            # degrades to inconclusive (pass-through). macOS has no per-string
+            # cap, so that failure mode was Linux-only.
             _nm_status=$(
-                _NM_FILES="$_nm_files" \
-                _NM_TREE="." \
-                python3 -I "$_nm_scanner" 2>/dev/null \
-                    || echo "INCONCLUSIVE:detector_error"
+                printf '%s\n' "$_nm_files" | {
+                    _NM_TREE="." \
+                    python3 -I "$_nm_scanner" 2>/dev/null \
+                        || echo "INCONCLUSIVE:detector_error"
+                }
             )
         fi
         case "$_nm_status" in
@@ -3135,6 +3141,25 @@ ISSUES: CRITICAL:description (optional, one per line per issue)"
                 _provider_rc=$?
             fi
             ;;
+        *)
+            # v8.2.0 TIMEOUT SEAM. Any provider exposing provider_invoke_argv can
+            # cast a real council vote instead of falling straight to the
+            # heuristic. argv is a REAL command, so `timeout` bounds it exactly as
+            # it bounds the named arms above (providers/claude.sh:321).
+            #
+            # SEMANTICS PRESERVED: _provider_rc is captured the same way, so the
+            # bash-F4 safe default below still forces a conservative REJECT on a
+            # timeout kill (124/137/143). An empty verdict falls to
+            # council_heuristic_review, identical to a missing CLI today.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                provider_invoke_argv fast "$prompt"
+                # caveman HARD-SUPPRESS: this vote is parsed for "VOTE:".
+                verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)
+                _provider_rc=$?
+            fi
+            ;;
     esac
 
     # bash-F4 (WAVE10 SAFE-DEFAULT): a provider timeout (124, incl. 128+SIGTERM
@@ -3303,6 +3328,22 @@ REASON: your reasoning"
                 verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" aider --message "$prompt" --yes-always --no-auto-commits --no-git 2>/dev/null)
             fi
             ;;
+        *)
+            # v8.2.0 TIMEOUT SEAM (contrarian / devil's-advocate vote). Same
+            # rationale as the member vote: a real argv keeps the `timeout`
+            # bound that a shell function would silently remove.
+            #
+            # SEMANTICS PRESERVED: this path tracks no _provider_rc by design --
+            # an empty verdict (timeout or failure) already routes to the
+            # conservative REJECT fallback immediately below.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                provider_invoke_argv fast "$prompt"
+                # caveman HARD-SUPPRESS: parsed for "VOTE:".
+                verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)
+            fi
+            ;;
     esac
 
     if [ -z "$verdict" ]; then

package/autonomy/council-v2.sh

@@ -441,7 +441,29 @@ except Exception:
             fi
             ;;
         *)
-            result='{"verdict":"INCONCLUSIVE","reasoning":"review not supported for this provider (no verdict obtained; NOT a rejection)","issues":[]}'
+            # v8.2.0 TIMEOUT SEAM. A provider exposing provider_invoke_argv gets
+            # a real reviewer instead of an automatic INCONCLUSIVE. The argv is a
+            # REAL command so `timeout` genuinely bounds it (providers/claude.sh:321);
+            # routing this through a shell function would silently drop the bound.
+            #
+            # VERDICT SEMANTICS UNCHANGED: on empty output, non-zero exit, or a
+            # timeout kill (124/137/143) we fall back to the SAME INCONCLUSIVE
+            # string used below -- never REJECT. A judge that produced no
+            # judgement has not rejected anything (v8.1.0 TRUST-3).
+            result=''
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                local _c2_seam_rc=0
+                provider_invoke_argv fast "$full_prompt"
+                # caveman HARD-SUPPRESS: this verdict is parsed for the JSON
+                # "verdict" field; compression would reword it.
+                result="$(timeout "${LOKI_SDK_REVIEW_TIMEOUT:-180}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)" || _c2_seam_rc=$?
+                [ "$_c2_seam_rc" -ne 0 ] && result=''
+            fi
+            if [ -z "$result" ]; then
+                result='{"verdict":"INCONCLUSIVE","reasoning":"review not supported for this provider (no verdict obtained; NOT a rejection)","issues":[]}'
+            fi
             ;;
     esac
 
@@ -452,6 +474,46 @@ except Exception:
         # Try removing markdown fencing
         extracted=$(echo "$result" | sed 's/^```json//;s/^```//' | sed -n '/^{/,/^}/p' | head -50)
     fi
+    # STRUCTURE-TOLERANT RECOVERY (v8.2.0).
+    #
+    # A strict JSON carve is the single most model-sensitive contract in the
+    # engine: schema adherence is exactly what varies most across models, while
+    # every coding model can state a verdict in prose. Measured elsewhere (Forge
+    # replication): scaffolding drove tool-call errors 42 -> 0 while
+    # advanced-reasoning accuracy stayed flat -- i.e. a harness CAN rescue
+    # format compliance but cannot manufacture judgment. So recovering a verdict
+    # the model genuinely expressed is legitimate; inventing one is not.
+    #
+    # This runs ONLY when the JSON carve produced nothing, and it accepts a
+    # verdict only when the model stated it UNAMBIGUOUSLY (exactly one of
+    # APPROVE/REJECT appears as a standalone word). A response mentioning both,
+    # or neither, stays INCONCLUSIVE -- never guessed.
+    if [ -z "$extracted" ] && [ -n "${result:-}" ]; then
+        local _recovered
+        _recovered="$(printf '%s' "$result" | _LOKI_RAW="$result" python3 -c '
+import os, re, sys, json
+raw = os.environ.get("_LOKI_RAW", "")
+# Standalone words only: "APPROVE" not "approved-by", and not inside a URL.
+approve = len(re.findall(r"(?<![A-Za-z0-9_-])APPROVE(?![A-Za-z0-9_-])", raw, re.I))
+reject  = len(re.findall(r"(?<![A-Za-z0-9_-])REJECT(?![A-Za-z0-9_-])",  raw, re.I))
+if approve and not reject:
+    v = "APPROVE"
+elif reject and not approve:
+    v = "REJECT"
+else:
+    sys.exit(1)   # ambiguous or absent -> stay inconclusive
+print(json.dumps({
+    "verdict": v,
+    "reasoning": "recovered from unstructured output (model stated %s in prose)" % v,
+    "issues": [],
+    "recovered": True,
+}))
+' 2>/dev/null)" || _recovered=""
+        if [ -n "$_recovered" ]; then
+            extracted="$_recovered"
+        fi
+    fi
+
     if [ -z "$extracted" ]; then
         # The weak-model case, and the reason this matters most: a model whose
         # prose could not be carved into JSON did not vote REJECT. Recording one

package/autonomy/grill.sh

@@ -158,6 +158,12 @@ grill_check_provider() {
             fi
             ;;
         *)
+            # v8.2.0: capability, not identity. Must stay in lockstep with the
+            # matching arm in grill_invoke_provider -- this gate runs FIRST, so
+            # rejecting here would make that arm dead code.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                return 0
+            fi
             _grill_err "grill currently supports the claude and codex providers (got: $provider)"
             return $GRILL_EXIT_ERROR
             ;;
@@ -278,6 +284,32 @@ grill_invoke_provider() {
             return 0
             ;;
         *)
+            # v8.2.0 TIMEOUT SEAM. Previously any other provider was a hard
+            # error. A provider exposing provider_invoke_argv builds a REAL argv
+            # (not a shell function), so _grill_with_timeout still bounds it --
+            # the whole reason the seam exists (providers/claude.sh:321).
+            # Nothing to preserve on this arm, so nothing can regress: it
+            # produced no output at all before.
+            #
+            # Deliberate: no --disallowedTools. That flag is claude-specific with
+            # no portable equivalent, so a seam-provider grill CAN write to the
+            # tree. Accepted; the alternative is the hard error below.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                local out
+                provider_invoke_argv fast "$prompt"
+                # env CAVEMAN_DEFAULT_MODE=off: grill output is parsed downstream
+                # and caveman compression would reword the questions. `env` (not a
+                # bare prefix) because _grill_with_timeout execs its first token.
+                out="$(_grill_with_timeout "${LOKI_GRILL_TIMEOUT:-180}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)"
+                if [ -z "$out" ]; then
+                    _grill_err "provider returned no output (timeout or invocation error)"
+                    return $GRILL_EXIT_ERROR
+                fi
+                printf '%s\n' "$out"
+                return 0
+            fi
             _grill_err "grill currently supports the claude and codex providers (got: $provider)"
             return $GRILL_EXIT_ERROR
             ;;

package/autonomy/lib/done-recognition.sh

@@ -159,12 +159,24 @@ except Exception:
     return 0
 }
 
-# Decide whether model verification can be attempted. Returns 0 (ok) only when
-# the active provider is claude and not degraded. Mirrors
-# _loki_prd_enrich_provider_ok (autonomy/lib/prd-enrich.sh:65).
+# Decide whether model verification can be attempted.
+#
+# v8.2.0: this used to require LOKI_PROVIDER=claude specifically, so a user on
+# codex/opencode/cline/aider silently lost done-recognition. That is a
+# CAPABILITY question, not an identity question -- the real requirement is "can
+# we reach a model AND bound the call with a timeout". Any provider exposing the
+# argv seam (provider_invoke_argv, see providers/claude.sh) satisfies both.
+#
+# Falls back to the historical claude-binary check when the seam is absent, so
+# nothing regresses for existing installs.
 _loki_done_recog_provider_ok() {
-    [ "${LOKI_PROVIDER:-claude}" = "claude" ] || return 1
     [ "${PROVIDER_DEGRADED:-false}" != "true" ] || return 1
+    # Preferred: a provider that can build a timeout-able argv.
+    if type provider_invoke_argv >/dev/null 2>&1; then
+        return 0
+    fi
+    # Legacy path: claude binary present.
+    [ "${LOKI_PROVIDER:-claude}" = "claude" ] || return 1
     command -v claude >/dev/null 2>&1 || return 1
     return 0
 }