loki-mode 11.63.2 → 11.63.4

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Runs an autonomous software factory that knows what it is supposed to deliver and proves it did, with a signed receipt. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v11.63.2
+# Loki Mode v11.63.4
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the previous bash loop. PRD-file starts (`loki start ./prd.md`) and the opencode provider still run on it until FC38-SWEEP ports them; the legacy-engine command and the LOKI_ENGINE switch remain removed. Prefer `loki owner/repo#N` for issues.
 
@@ -476,4 +476,4 @@ Implemented, planned and deprecated items, with the version each landed in: `ski
 
 ---
 
-**v11.63.2 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.63.4 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.63.2
+11.63.4

package/dashboard/__init__.py

@@ -7,6 +7,6 @@ Modules:
     control: Session control helpers (status, atomic writes, origin check)
 """
 
-__version__ = "11.63.2"
+__version__ = "11.63.4"
 
 __all__ = ["__version__"]

package/docs/CLI-REFERENCE.md

@@ -1,6 +1,6 @@
 # CLI reference
 
-Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.63.2. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.63.4. Do not edit by hand.
 Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for the full inventory.
 
 | Command | Description |

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Loki Mode, by [Autonomi](https://www.autonomi.dev/), turns a spec or an issue into a verified pull request with a receipt you can check. This page covers installing it, a first run, and the options around it.
 
-**Version:** v11.63.2
+**Version:** v11.63.4
 
 **Engine note:** `loki start` is the primary command. `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` all run the Loki 10 engine, whatever the flag order or input form (PRD file, issue ref, task or one-word brief). The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present. See the [user guide](v10/GUIDE.md) and the [5-minute quickstart](QUICKSTART.md).
 

package/docs/v10/FAILURE-CLASSES.md

@@ -1718,3 +1718,37 @@ L0 review rule (ENGINE-LAWS.md L0): a fix that adds an `if` or a regex about the
 - Siblings swept: loki-ts/src/engine10 neither writes nor reads the pointer (`git grep -n last-proof-id -- loki-ts/src/engine10` returns nothing). The readers (run.sh, loki, run-summary.sh, trigger-server.py) are route-agnostic and unchanged.
 - Mechanism: clearStaleProofPointer in runner/proof.ts, called once from runAutonomous right after makeContext.
 - Fixture: loki-ts/tests/runner/autonomous.test.ts "#211 Bun-route sibling" seeds run-A, stops the run before proof with LOKI_PROOF=0, expects the pointer absent. Mutant: remove the call in runAutonomous; the test goes red.
+
+## FC-WALL-FILE-NOT-DISCOVERED-BY-RUNNER Verify runs the Wall only if the stack's test discovery also finds it, so a sealed loki_wall_*.py is never run and the receipt says "wall result not recorded by verify"
+- User-visible vs raw: user-visible. A Python run with a Wall file (`loki_wall_x.py`) never executes the Wall in verify; wall_passed stays undefined and Seal lists "wall result not recorded by verify" (seal.ts:250) as NOT PROVEN even though the Wall was authored, sealed and green on the base run.
+- Law: the Wall is the proof the run is judged by, so verify runs exactly the files the Wall sealed (outputs wall.files), never whichever of them the runner's discovery filter happens to list.
+- Cause (measured): wall.ts names every Wall file with the `loki_wall_` prefix and picks its runner with `guessRunner`; verify.ts built `wallTests` as `map.tests.filter(t => wallPaths.has(t.path))`, and `map.tests` comes from detect(), which pytest discovery limits to `test_*.py` and `*_test.py`. `loki_wall_x.py` matches neither, so the filter dropped it. The JS-only harness fallback below it covered one stack.
+- Siblings swept: Go (`loki_wall_x_test.go` ends in `_test.go`, so detect lists it and the old filter worked; the new path keeps it, with a regression fixture), JS (kept: the harness fallback is now the same code path, runner chosen by guessRunner), Rust (NOT closed here: guessRunner has no `.rs` mapping and `cargo test` takes no file argument, so a sealed Rust Wall file has no runner in wall.ts either; open as its own row against wall.ts).
+- Mechanism: `guessRunner` moved from wall.ts to testmap.ts (beside harnessRunners) and is exported; verify builds wallTests from the sealed paths with it, reusing the discovered ref when detect() already lists the file.
+- Fixture: loki-ts/tests/engine10/verify.test.ts "FC-WALL-FILE-NOT-DISCOVERED-BY-RUNNER" holding loki_wall_x.py beside test_x.py (red on origin/main: the Wall check is absent), plus a Go loki_wall_x_test.go case.
+
+## FC-WALL-RUST-FILE-HAS-NO-RUNNER A Rust Wall file is sealed and shipped but nothing ever runs it: guessRunner has no .rs mapping and the cargo command takes no file, so the Wall proves nothing on a Rust repo
+- User-visible vs raw: user-visible. On a Rust repo the Wall author writes `loki_wall_x.rs`; wall.ts seals it (wall.sealed lists it) but `guessRunner` returns null, so the base run skips it and verify (after FC-WALL-FILE-NOT-DISCOVERED-BY-RUNNER) builds no check for it. The receipt carries a Wall that was never executed and says nothing about it.
+- Law: a sealed Wall file is either run by a runner that names it, or reported NOT PROVEN with the reason; it is never silently dropped and no check is invented for it.
+- Cause (measured): `guessRunner` in testmap.ts mapped .py, .go and JS only; `runnerCmd` in check_result.ts ran `cargo test` for every cargo ref, which selects no file. Cargo selects a single integration-test file only as `cargo test --test <stem>`, and only for a file directly under a `tests/` directory.
+- Siblings swept: Go and JS already map (FC-WALL-FILE-NOT-DISCOVERED-BY-RUNNER). Other extensions (.java, .rb, .c) still have no mapping and are not covered here; they are named in the open list below.
+- Mechanism: `guessRunner(path, runners)` takes the path and returns "cargo" for `<dir>/tests/<name>.rs` when the repo has the cargo runner; `runnerCmd` runs `cargo test --test <name>` for such a file; a sealed .rs path with no per-file runner is named by the generic FC-WALL-FILE-WITHOUT-RUNNER-SILENTLY-DROPPED line in not_proven ("Wall test not executed: <path>: no runner of this repo runs this file"). A cargo per-file red stays not_run (the coarse rule), never a false green.
+- Open siblings: Wall files with extensions that guessRunner does not map (anything other than .py, .go, .rs, JS/TS) are still sealed without a runner or a not_proven note.
+- Fixture: loki-ts/tests/engine10/verify.test.ts "FC-WALL-RUST-FILE-HAS-NO-RUNNER" (tests/loki_wall_x.rs runs `cargo test --test loki_wall_x`; src/loki_wall_x.rs is NOT PROVEN with the reason and invents no check) and loki-ts/tests/engine10/testmap.test.ts guessRunner cases.
+
+## FC-WALL-GO-FILE-RUNS-WHOLE-PACKAGE A sealed Go Wall file is run as `go test ./<dir>`, the whole package, so a sibling test in the same package decides the Wall result
+- User-visible vs raw: user-visible. A Go Wall file `loki_wall_x_test.go` shares its package directory with the repo's own tests. Verify ran `go test -json ./<dir>`, so a red or slow sibling test (written by the repo, not the Wall) turns the Wall check red or hides what the Wall file proves.
+- Law: a Wall check reports on the Wall file, not on its neighbours. Go exit 0 stays never a pass (FC-16b): this row narrows what runs, it does not change how a Go result is trusted.
+- Cause (measured): `runnerCmd` case "go" in check_result.ts ignored the file name and passed only `./${dirname(t.path)}`.
+- Siblings swept: cargo is already per-file (FC-WALL-RUST-FILE-HAS-NO-RUNNER); pytest, vitest, jest, bun and node already take the file path. Go is the last per-file gap.
+- Mechanism: `runnerCmd` reads the file's top-level Test, Fuzz and Example function names by name only, never by signature (TestMain excluded; a signature check dropped multi-line, unnamed, aliased or dot-imported `*testing.T` and non-ASCII names, turning a red Wall into not_run, rev-b B1) and runs `go test -json -run '^(TestA|TestB)$' ./<dir>`. A file with no such function keeps the package run (it can only end not_run). The classification is unchanged: exit 0 is not_run (GO_EXIT0_REASON), a failed run is fail only with real failure evidence.
+- Open (needs a ruling, not decided here): a Go Wall file can never reach pass under FC-16b, so `wall_passed` stays unset for a Go-only repo and the receipt keeps saying the Wall result is not recorded. A pass from "exit 0 plus an ok line" would reopen the forgery FC-16b closed (TestMain os.Exit(0), a test printing `ok pkg`).
+- Fixture: loki-ts/tests/engine10/verify.test.ts "FC-WALL-GO-FILE-RUNS-WHOLE-PACKAGE" (a red sibling test in the package does not make the Wall check fail; the argv carries -run with the file's test names) and a runnerCmd unit case.
+
+## FC-TEST-ALIAS-FWD-REDUNDANT-SPAWN The alias-forwarding suite re-ran the same alias --json command for two assertions, so its CLI spawn floor was higher than its assertions need (#183)
+- User-visible vs raw: raw. No product behavior changes; the suite is load-sensitive and a spawn count that is higher than needed lengthens every loaded run.
+- Law: one command run feeds every assertion that reads the same stdout, unless the command has a side effect the second run depends on.
+- Cause (measured): in tests/cli/test-alias-forwarding.sh assert_row, the alias --json command ran once for the stderr-suppression check and again for the 4b stdout parity check. The suite did 168 CLI spawns on origin/main 5cae48655 (counted by a wrapper around bin/loki, same on LOKI_ROUTE=bun and LOKI_ROUTE=bash).
+- Siblings swept: the export row cannot share the run: `export markdown --json` treats --json as an output filename, so the first run creates it and the canonical comparison relies on the second alias run seeing it already exist (first-run output "Exported to --json", later "File already exists: --json"; found when sharing it turned the row red). It keeps its second spawn. The other assert_row spawns each read distinct output.
+- Mechanism: the --json run keeps its stdout in a per-unit file and the 4b check reads it; every spawn goes through a counting wrapper and the total prints before the results line.
+- Fixture: the printed "CLI spawns" line (168 before, 154 after) with 202 passed and 9 failed on both routes before and after (the 9 are the stale help-group reds, a separate row). Mutant: make the alias lookup return the canonical stdout; with a planted differing alias stdout, 14 rows fail without the mutant and 0 with it.