loki-mode 10.6.10 → 10.6.12

package/README.md

@@ -19,6 +19,7 @@ Before a build counts as done, a review council selects reviewers from a special
 - [Loki 10 engine](#loki-10-engine)
 - [Outcomes and exit codes](#outcomes-and-exit-codes)
 - [Signed receipts and loki verify](#signed-receipts-and-loki-verify)
+- [loki workspace](#loki-workspace)
 - [Quiet output](#quiet-output)
 - [Release channels: next and latest](#release-channels-next-and-latest)
 - [loki doctor](#loki-doctor)
@@ -234,9 +235,26 @@ loki verify
 
 A verified receipt is bound to the run's event log, so a receipt lifted out of its run, or a log edited after sealing, does not verify. Signing proves the receipt came from the key holder; it does not prove the generated code is bug-free. A receipt only claims what its checks ran, and states what they did not.
 
-### Visual evidence (opt-in)
+### Export as a DSSE envelope
 
-With `LOKI_VISUAL_EVIDENCE=1`, a v10 run that changed web page files (html, jsx, tsx, vue, svelte under app/, pages/, src/ or public/) starts the repo's dev, preview or start script and screenshots each changed route with the repo's own Playwright (nothing is downloaded) into a fresh per-run directory `.loki/runs/<run_id>/evidence/<random>/` (at most 5 routes, total capture budget 25s, aborted with the seal stage). API-only repos with an openapi file get an HTTP transcript at `.loki/runs/<run_id>/evidence/<random>/http.json` (not hashed into the receipt). Each screenshot's sha256 is recorded in the receipt as `evidence_screens`, the PR body gets an Evidence section, and `loki verify` reports TAMPERED if a recorded screenshot is altered, missing or a symlink. Capture never fails the run; a skip is listed in NOT PROVEN. Off by default.
+`loki verify <run> --export-dsse > receipt.dsse.json` wraps a verified v10 receipt as a DSSE envelope whose payload is an in-toto Statement v1, signed with the Ed25519 receipt key. The export refuses unless the receipt verifies (exit 1 if tampered, 2 if unsigned or unchecked, 66 if no signing key is found) and its run outcome is `VERIFIED` or `ALREADY_SATISFIED` (exit 4 otherwise, empty stdout). It takes a receipt, not an envelope (exit 1), and an envelope found under a run id must carry that run id (exit 1). Example: `loki verify 20261003-abc --export-dsse > r.dsse.json; echo $?` prints 4 for a failed run. `loki verify receipt.dsse.json` accepts the envelope too; add `--pubkey FILE` on another machine. Details: [docs/SIGNED-RECEIPTS.md](docs/SIGNED-RECEIPTS.md).
+
+### Visual evidence (on by default)
+
+By default (set `LOKI_VISUAL_EVIDENCE=0` to turn it off), a v10 run that changed web page files (html, jsx, tsx, vue, svelte under app/, pages/, src/ or public/) starts the repo's dev, preview or start script and screenshots each changed route with the repo's own Playwright (nothing is downloaded) into a fresh per-run directory `.loki/runs/<run_id>/evidence/<random>/` (at most 5 routes, total capture budget 25s, aborted with the seal stage). With an explicit `LOKI_VISUAL_EVIDENCE=1`, API-only repos with an openapi file also get an HTTP transcript at `.loki/runs/<run_id>/evidence/<random>/http.json` (not hashed into the receipt). Each screenshot's sha256 is recorded in the receipt as `evidence_screens`, the PR body gets an Evidence section, and `loki verify` reports TAMPERED if a recorded screenshot is altered, missing or a symlink. Capture never fails the run; a skip is listed in NOT PROVEN. On by default; it needs Playwright in the repo and changed pages, otherwise it only adds one NOT PROVEN line.
+
+## loki workspace
+
+`loki workspace` runs one issue across several repos. Define groups under the `workspaces` key in `loki.yaml` (each with `repos`, optional per-repo `path`, `setup` and `after`, and an optional `integration` command), then:
+
+```bash
+loki workspace list                        # configured workspaces
+loki workspace show <name>                 # one workspace's repos and order
+loki workspace run <name> owner/repo#N     # or a task text instead of an issue ref
+loki workspace status [<run-id>]           # recorded runs, one row per repo
+```
+
+Each repo gets its own worktree and engine run. The command exits 0 only when every repo and the integration step succeed, 3 when the only failures are budget stops, and 1 otherwise. After the integration step, a PR comment is posted on each repo's PR (when one exists) showing the integration status and every head SHA; `LOKI_WORKSPACE_COMMENT=0` turns it off. `LOKI_WORKSPACES=0` disables the whole command. Full reference: [docs/WORKSPACES.md](docs/WORKSPACES.md).
 
 ## Quiet output
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: An autonomous software factory that knows what it is supposed to deliver, and proves it did. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v10.6.10
+# Loki Mode v10.6.12
 
 **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 legacy engine, which still ships and is being removed (`loki start owner/repo#N` still routes to it; prefer `loki owner/repo#N`).
 
@@ -473,4 +473,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v10.6.10 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v10.6.12 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-10.6.10
+10.6.12

package/autonomy/lib/backlog.py

@@ -84,11 +84,14 @@ def ledger_path():
 
 
 def spent_today():
+    """USD spent today, 0.0 if no ledger yet, None if the ledger is unreadable (fail closed)."""
     try:
         with open(ledger_path()) as f:
             return float(json.load(f).get(datetime.date.today().isoformat(), 0))
-    except (OSError, ValueError):
+    except FileNotFoundError:
         return 0.0
+    except (OSError, ValueError, TypeError, AttributeError):
+        return None
 
 
 def add_spend(usd):
@@ -96,7 +99,16 @@ def add_spend(usd):
     try:
         with open(p) as f:
             data = json.load(f)
+        if not isinstance(data, dict):
+            raise ValueError("ledger is not an object")
+    except FileNotFoundError:
+        data = {}
     except (OSError, ValueError):
+        # Keep the unreadable bytes; never overwrite history.
+        try:
+            os.replace(p, "%s.corrupt-%d" % (p, int(time.time())))
+        except OSError:
+            pass
         data = {}
     k = datetime.date.today().isoformat()
     data[k] = round(float(data.get(k, 0)) + usd, 6)
@@ -380,9 +392,13 @@ def main(argv):
         for k in [k for k, (p, _l, _w) in running.items() if p.poll() is not None]:
             finish(k)
         while pending and len(running) < conc:
-            if day_cap and spent_today() >= day_cap:
+            spent = spent_today() if day_cap else 0.0
+            if day_cap and (spent is None or spent >= day_cap):
                 for k in pending:
-                    state[k].update(status="BUDGET_STOP: daily budget $%.2f reached ($%.2f spent)" % (day_cap, spent_today()), ok=False)
+                    if spent is None:
+                        state[k].update(status="BUDGET_STOP: daily budget $%.2f set but spend ledger unreadable (ledger unreadable)" % day_cap, ok=False)
+                    else:
+                        state[k].update(status="BUDGET_STOP: daily budget $%.2f reached ($%.2f spent)" % (day_cap, spent), ok=False)
                     say("backlog: %s %s" % (spec[k]["label"], state[k]["status"]))
                 pending = []
                 break

package/autonomy/lib/fast_verify.py

@@ -314,6 +314,10 @@ def verify(root: str = ".", diff_base: str = "", use_cache: bool = True) -> Resu
     )
 
 
+USAGE = """usage: fast_verify.py [ROOT] [--path DIR] [--diff-base REF] [--no-cache] [--json] [-h|--help]
+exit codes: 0 PASS, 1 FAIL, 2 root not found, 3 INCONCLUSIVE, 64 unknown option"""
+
+
 def main(argv: list) -> int:
     root, base, use_cache, as_json = ".", "", True, False
     i = 0
@@ -321,14 +325,26 @@ def main(argv: list) -> int:
         a = argv[i]
         if a == "--diff-base" and i + 1 < len(argv):
             base = argv[i + 1]; i += 1
+        elif a == "--path" and i + 1 < len(argv):
+            root = argv[i + 1]; i += 1
+        elif a in ("-h", "--help"):
+            print(USAGE)
+            return 0
         elif a == "--no-cache":
             use_cache = False
         elif a == "--json":
             as_json = True
         elif not a.startswith("-"):
             root = a
+        else:
+            print(f"fast_verify: unknown option: {a}", file=sys.stderr)
+            return 64
         i += 1
 
+    if not os.path.isdir(root):
+        print(f"fast_verify: root not found: {root}", file=sys.stderr)
+        return 2
+
     r = verify(root, base, use_cache)
     if as_json:
         print(json.dumps(asdict(r), indent=2))
@@ -339,7 +355,9 @@ def main(argv: list) -> int:
             print(f"  [{f['severity']}] {f['rule']} {f['path']}:{f['line']} - {f['message']}")
         if len(r.findings) > 20:
             print(f"  ... and {len(r.findings) - 20} more")
-    return 1 if r.verdict == "FAIL" else 0
+    if r.verdict == "FAIL":
+        return 1
+    return 3 if r.verdict == "INCONCLUSIVE" else 0
 
 
 if __name__ == "__main__":

package/autonomy/lib/proof-pr.sh

@@ -32,6 +32,35 @@
 # every optional tool is `command -v`-guarded. All print paths `return 0` so a
 # sourced call cannot abort the caller under set -e.
 
+# S-215: callers render from the agent's repo, and a bare `python3 -` puts the
+# cwd first on sys.path, so a committed json.py forged the headline. The
+# renderer resolves its interpreter through _loki_snapshot_py_tool and runs it
+# -I -S. The copy below only serves callers that source this file on its own;
+# run.sh's definition is the source of truth: keep this copy byte-identical to
+# it. Pinned by tests/test-proof-pr-no-cwd-shadow.sh and
+# tests/test-council-py-tool-identity.sh.
+declare -F _loki_snapshot_py_tool >/dev/null 2>&1 || \
+_loki_snapshot_py_tool() {
+    local c
+    for c in /usr/bin/python3 /bin/python3; do
+        [ -x "$c" ] && [ ! -d "$c" ] && "$c" -I -S -c '' >/dev/null 2>&1 && { printf '%s\n' "$c"; return 0; }
+    done
+    local dir
+    local IFS=:
+    for dir in $PATH; do
+        case "$dir" in
+            /*) ;;
+            *) continue ;;
+        esac
+        if [ -x "$dir/python3" ] && [ ! -d "$dir/python3" ] \
+           && "$dir/python3" -I -S -c '' >/dev/null 2>&1; then
+            printf '%s\n' "$dir/python3"
+            return 0
+        fi
+    done
+    return 1
+}
+
 # Double-source guard.
 [ -n "${_PROOF_PR_SH:-}" ] && return 0
 _PROOF_PR_SH=1
@@ -52,8 +81,10 @@ render_evidence_receipt_md() {
     local _expected_base_sha="${3:-}"
     : "$_expected_base_sha"
 
-    # No python3 -> degrade honestly, never crash.
-    if ! command -v python3 >/dev/null 2>&1; then
+    # No isolated python3 -> degrade honestly, never crash.
+    local _pr_py=""
+    _pr_py="$(_loki_snapshot_py_tool)" || _pr_py=""
+    if [ -z "$_pr_py" ]; then
         printf '%s\n' "Evidence Receipt: unavailable for this run."
         return 0
     fi
@@ -67,7 +98,7 @@ render_evidence_receipt_md() {
     # resort (interpreter crash) -> print the single honest line.
     local _receipt_out=""
     local _receipt_rc=0
-    _receipt_out="$(python3 - "$proof_json_path" "$expected_head_sha" <<'PROOF_PR_PY' 2>/dev/null
+    _receipt_out="$("$_pr_py" -I -S - "$proof_json_path" "$expected_head_sha" <<'PROOF_PR_PY' 2>/dev/null
 import json
 import sys
 

package/autonomy/lib/workspace.py

@@ -208,6 +208,7 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
     child_env_base = dict(os.environ, LOKI_ENGINE="v10", LOKI_NO_BROWSER="1")
 
     outcome, worktrees, heads, kind = {}, {}, {}, {}
+    timing = {}  # repo -> {started_at, finished_at} epoch seconds
     running = {}  # repo -> (Popen, log file handle)
     try:
         conc = max(1, int(os.environ.get("LOKI_WORKSPACE_CONCURRENCY") or ws.get("concurrency") or 2))
@@ -220,6 +221,22 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
                 os.killpg(p.pid, signal.SIGTERM)
             except OSError:
                 pass
+        now = time.time()
+        for r in list(running):
+            outcome[r] = "INTERRUPTED"
+            kind[r] = "fail"
+            timing[r]["finished_at"] = now
+        for e in pending:
+            outcome.setdefault(e["repo"], "INTERRUPTED (not started)")
+        try:
+            ev_i = {"status": "interrupted", "outcomes": outcome,
+                    "timing": {r: t for r, t in timing.items() if "finished_at" in t}}
+            ip = os.path.join(run_dir, "integration.json")
+            with open(ip + ".tmp", "w") as f:
+                json.dump(ev_i, f, indent=2, sort_keys=True)
+            os.replace(ip + ".tmp", ip)
+        except OSError:
+            pass
         sys.exit(130)
     if threading.current_thread() is threading.main_thread():
         signal.signal(signal.SIGTERM, stop)
@@ -260,12 +277,14 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
             p = subprocess.Popen([launcher, arg], cwd=wt, env=dict(child_env_base, **extra), stdout=lf,
                                  stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True)
             running[repo] = (p, lf)
+            timing[repo] = {"started_at": time.time()}
         for repo, (p, lf) in list(running.items()):
             rc = p.poll()
             if rc is None:
                 continue
             lf.close()
             running.pop(repo)
+            timing[repo]["finished_at"] = time.time()
             if rc == 0:
                 outcome[repo], kind[repo] = "ok", "ok"
             else:
@@ -281,6 +300,7 @@ def run_workspace(name, ref, workspaces, base_dir=None, launcher=None):
 
     ev = run_integration(ws, run_dir, worktrees, heads)
     ev["outcomes"] = outcome
+    ev["timing"] = {r: t for r, t in timing.items() if "finished_at" in t}
     ev_path = os.path.join(run_dir, "integration.json")
     tmp = ev_path + ".tmp"
     with open(tmp, "w") as f:
@@ -314,8 +334,11 @@ def _runs(base_dir):
             try:
                 with open(path) as f:
                     yield name, run_id, json.load(f)
-            except (OSError, ValueError):
+            except FileNotFoundError:
                 continue
+            except (OSError, ValueError) as e:
+                yield name, run_id, {"state": "unreadable", "status": "unreadable",
+                                     "error": "%s: %s" % (type(e).__name__, e)}
 
 
 def status(base_dir, run_id=None, say=say):
@@ -328,6 +351,9 @@ def status(base_dir, run_id=None, say=say):
         say("%s %s" % (name, rid))
         for repo, res in sorted((ev.get("outcomes") or {}).items()):
             say("%-30s %s" % (repo, res))
+        if ev.get("state") == "unreadable":
+            say("%-30s %s (%s)" % ("integration", "unreadable", ev.get("error")))
+            continue
         say("%-30s %s" % ("integration", ev.get("status")))
     return 0
 

package/autonomy/lib/workspace_metrics.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""loki workspace metrics: PRs per wall-clock hour and per attention minute (D51-B15).
+
+    python3 workspace_metrics.py <integration.json | run-dir> [--attention-min N]
+
+Reads the per-repo `timing` ({repo: {started_at, finished_at}} in epoch
+seconds) that `loki workspace run` records in integration.json. A PR is a repo
+whose outcome is "ok". Wall clock is the earliest start to the latest finish.
+A run without timestamps (an older integration.json, or a repo missing its
+timing) is reported as "unmeasured", never as zero. Attention minutes are the
+human minutes the operator spent; they are not recorded by the runner, so the
+per-attention rate is "unmeasured" unless --attention-min is given.
+"""
+import json
+import os
+import sys
+
+UNMEASURED = "unmeasured"
+
+
+def compute(ev, attention_min=None):
+    """Return a dict of metric name -> number or UNMEASURED."""
+    outcomes = ev.get("outcomes") or {}
+    timing = ev.get("timing") or {}
+    ok_repos = [r for r, o in outcomes.items() if o == "ok"]
+    out = {"prs": len(ok_repos), "wall_clock_seconds": UNMEASURED,
+           "prs_per_hour": UNMEASURED, "prs_per_attention_minute": UNMEASURED}
+
+    spans = []
+    complete = bool(timing) and all(
+        isinstance(timing.get(r), dict)
+        and isinstance(timing[r].get("started_at"), (int, float))
+        and isinstance(timing[r].get("finished_at"), (int, float))
+        for r in ok_repos)
+    if complete:
+        for t in timing.values():
+            if isinstance(t, dict) and isinstance(t.get("started_at"), (int, float)) \
+                    and isinstance(t.get("finished_at"), (int, float)):
+                spans.append((t["started_at"], t["finished_at"]))
+    wall = (max(f for _, f in spans) - min(s for s, _ in spans)) if spans else None
+    if wall is not None and wall > 0:
+        out["wall_clock_seconds"] = round(wall, 1)
+        out["prs_per_hour"] = out["prs"] / (wall / 3600.0)
+    if out["prs_per_hour"] != UNMEASURED and attention_min is not None and attention_min > 0:
+        out["prs_per_attention_minute"] = out["prs"] / attention_min
+    return out
+
+
+def _fmt(key, val):
+    if val == UNMEASURED or key in ("prs", "wall_clock_seconds"):
+        return str(val)
+    return "%.4f" % val if key == "prs_per_attention_minute" else "%.2f" % val
+
+
+def main(argv):
+    attention = None
+    args = list(argv)
+    if "--attention-min" in args:
+        i = args.index("--attention-min")
+        try:
+            attention = float(args[i + 1])
+            del args[i:i + 2]
+        except (IndexError, ValueError):
+            print("workspace_metrics: --attention-min needs a number")
+            return 2
+    if len(args) != 1:
+        print("Usage: workspace_metrics.py <integration.json | run-dir> [--attention-min N]")
+        return 2
+    path = args[0]
+    if os.path.isdir(path):
+        path = os.path.join(path, "integration.json")
+    try:
+        with open(path) as f:
+            ev = json.load(f)
+    except (OSError, ValueError) as e:
+        print("workspace_metrics: cannot read %s: %s" % (path, e))
+        return 2
+    res = compute(ev, attention)
+    for key in ("prs", "wall_clock_seconds", "prs_per_hour", "prs_per_attention_minute"):
+        print("%s: %s" % (key, _fmt(key, res[key])))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/autonomy/lib/worktree_prep.py

@@ -12,6 +12,7 @@ import os
 import re
 import subprocess
 import sys
+import time
 
 DEP_DIRS = ("node_modules", ".venv", "venv", "vendor")
 
@@ -65,18 +66,59 @@ def _cow_copy(src, dst):
 
 
 def _escapes_source(path):
-    """True if a dep dir has an absolute symlink or an editable finder."""
+    """True if a dep dir links or points outside itself.
+
+    Flags absolute symlinks, relative symlinks resolving outside the dep dir,
+    editable finders, and bin/* scripts whose shebang names the source path.
+    """
+    base = os.path.realpath(path)
+    sources = {os.path.dirname(base).encode(), os.path.dirname(os.path.abspath(path)).encode()}
     for root, dirs, files in os.walk(path):
         for name in dirs + files:
             p = os.path.join(root, name)
             if os.path.islink(p):
-                if os.path.isabs(os.readlink(p)):
+                target = os.readlink(p)
+                if os.path.isabs(target):
+                    return True
+                real = os.path.realpath(os.path.join(root, target))
+                if real != base and not real.startswith(base + os.sep):
                     return True
             elif name.endswith(".pth") or name.startswith("__editable__"):
                 return True
+        if os.path.basename(root) == "bin":
+            for name in files:
+                p = os.path.join(root, name)
+                if os.path.islink(p):
+                    continue
+                try:
+                    with open(p, "rb") as f:
+                        first = f.readline(4096)
+                except OSError:
+                    continue
+                if first.startswith(b"#!") and any(x in first for x in sources):
+                    return True
     return False
 
 
+def _lock_timeout():
+    try:
+        return float(os.environ.get("LOKI_PREP_LOCK_TIMEOUT", "120"))
+    except ValueError:
+        return 120.0
+
+
+def _acquire_lock(lock):
+    deadline = time.monotonic() + _lock_timeout()
+    while True:
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            return
+        except OSError:
+            if time.monotonic() >= deadline:
+                raise RuntimeError("FAILED: lock contention")
+            time.sleep(0.1)
+
+
 def _copy_deps(source, dest, start):
     copied = 0
     for name in DEP_DIRS:
@@ -100,7 +142,7 @@ def prepare_worktree(source_repo, dest, branch, setup=None, base=None):
     dest = os.path.abspath(dest)
     lock = open(_lock_path(source_repo), "w")
     try:
-        fcntl.flock(lock, fcntl.LOCK_EX)
+        _acquire_lock(lock)
         left_out = _left_out_changes(source_repo)
         start = _start_point(source_repo, base)
         base_sha = _git(source_repo, "rev-parse", start + "^{commit}").stdout.strip()

package/autonomy/loki

@@ -1589,6 +1589,48 @@ PYEOF
 }
 
 # Show help
+# `loki help answer`: `loki answer` is a v10 (loki-ts) command with no bash
+# implementation, so its help lives here rather than behind delegation.
+_help_answer() {
+    echo -e "${BOLD}loki answer${NC} - Resume a BLOCKED run with an answer"
+    echo ""
+    echo "Usage: loki answer [<run-id>] [--text \"...\"]"
+    echo ""
+    echo "A run BLOCKED on a spec conflict has no in-place resume. This command"
+    echo "starts a fresh run whose task carries the original task plus the"
+    echo "question and your answer as context, then prints the new run id."
+    echo ""
+    echo "Arguments:"
+    echo "  <run-id>        BLOCKED run to answer. Default: the newest BLOCKED run"
+    echo "                  in the current repo (else the latest run)."
+    echo ""
+    echo "Options:"
+    echo "  --text \"...\"    The answer text (also --text=...). Without it, the answer is"
+    echo "                  read from the Control Plane answer file"
+    echo "                  \$LOKI_CONTROL_ANSWER_DIR/<source>/<run-id>.answer.txt"
+    echo "                  (default dir: ~/.loki/control/answers)."
+    echo ""
+    echo "Exit codes: 0 the new run succeeded (otherwise its exit code), 2 no runs,"
+    echo "run not BLOCKED, no answer supplied, or bad usage."
+    echo "The child run drops SLACK_* and LOKI_CONTROL_TOKEN from its environment"
+    echo "and sets LOKI_NO_BROWSER=1."
+}
+
+# Appended to `loki help verify`: the v10 DSSE export flag (docs/exit-codes.md).
+_help_verify_dsse() {
+    echo ""
+    echo "DSSE EXPORT (v10 engine):"
+    echo "    loki verify <run-id|receipt.json> --export-dsse"
+    echo "        Print a VERIFIED or ALREADY_SATISFIED run receipt as an in-toto"
+    echo "        Statement v1 inside a DSSE envelope (Ed25519 over PAE). Refusals"
+    echo "        print nothing on stdout. Exit codes:"
+    echo "          0   envelope printed"
+    echo "          1   TAMPERED, an envelope given as input, or run_id mismatch"
+    echo "          2   UNSIGNED, UNCHECKED, or unreadable receipt"
+    echo "          4   run outcome is not VERIFIED or ALREADY_SATISFIED"
+    echo "          66  no signing key, or no runs"
+}
+
 show_help() {
     local version=$(get_version)
     # Strip color when stdout is not a TTY (piped/redirected) so captured help
@@ -6215,8 +6257,14 @@ cmd_status() {
     if [ -f "$LOKI_DIR/metrics/budget.json" ]; then
         local budget_limit budget_used budget_remaining
         budget_limit=$(LOKI_BUDGET_FILE="$LOKI_DIR/metrics/budget.json" python3 -c "import json,os; d=json.load(open(os.environ['LOKI_BUDGET_FILE'])); print(d.get('budget_limit', 0))" 2>/dev/null || echo "0")
-        budget_used=$(LOKI_BUDGET_FILE="$LOKI_DIR/metrics/budget.json" python3 -c "import json,os; d=json.load(open(os.environ['LOKI_BUDGET_FILE'])); print(round(d.get('budget_used', 0), 2))" 2>/dev/null || echo "0")
-        if [ "$budget_limit" != "0" ]; then
+        budget_used=$(LOKI_BUDGET_FILE="$LOKI_DIR/metrics/budget.json" python3 -c "import json,os; d=json.load(open(os.environ['LOKI_BUDGET_FILE'])); v=d.get('budget_used'); print('unmeasured' if v is None else round(v, 2))" 2>/dev/null || echo "0")
+        if [ "$budget_used" = "unmeasured" ]; then
+            if [ "$budget_limit" != "0" ]; then
+                echo -e "${CYAN}Budget:${NC} unmeasured / \$$budget_limit"
+            else
+                echo -e "${CYAN}Cost:${NC} unmeasured"
+            fi
+        elif [ "$budget_limit" != "0" ]; then
             echo -e "${CYAN}Budget:${NC} \$$budget_used / \$$budget_limit"
             # Show budget gauge if TUI is loaded
             if type context_gauge &>/dev/null; then
@@ -6697,6 +6745,7 @@ total_input = sum(it.get('input_tokens', 0) for it in iterations)
 total_output = sum(it.get('output_tokens', 0) for it in iterations)
 total_tokens = total_input + total_output
 total_cost = sum(it.get('cost_usd', 0) for it in iterations)
+cost_measured = any(it.get('cost_usd') is not None for it in iterations)
 total_duration = sum(it.get('duration_seconds', 0) for it in iterations)
 
 # Budget
@@ -6854,7 +6903,10 @@ if iterations:
     print(f'  Input tokens:  {fmt_number(total_input)}')
     print(f'  Output tokens: {fmt_number(total_output)}')
     print(f'  Total tokens:  {fmt_number(total_tokens)}')
-    print(f'  Estimated cost: \${total_cost:.2f}')
+    if cost_measured:
+        print(f'  Estimated cost: \${total_cost:.2f}')
+    else:
+        print('  Estimated cost: unmeasured')
 else:
     print('  N/A (no iteration metrics found)')
 print()
@@ -22328,8 +22380,15 @@ main() {
                         # and a future spelling would slip past it.
                         if [ "${LOKI_HELP_ONLY:-}" = "1" ]; then
                             show_help
+                        elif [ "$_help_target" = "answer" ]; then
+                            _help_answer
                         else
                             LOKI_HELP_ONLY=1 "$0" "$_help_target" --help "$@"
+                            local _help_rc=$?
+                            if [ "$_help_target" = "verify" ] && [ "$_help_rc" -eq 0 ]; then
+                                _help_verify_dsse
+                            fi
+                            return "$_help_rc"
                         fi
                         ;;
                 esac