loki-mode 11.76.0 → 11.78.0

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.76.0
+# Loki Mode v11.78.0
 
 **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.
 
@@ -475,4 +475,4 @@ Implemented, planned and deprecated items, with the version each landed in: `ski
 
 ---
 
-**v11.76.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.78.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.76.0
+11.78.0

package/autonomy/lib/check_author.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Check-author context (moat P3, interface A in tests/moat/p3-the-wall.sh).
+
+  check_author.py context --spec <file> --repo <dir>
+
+Prints ONE JSON object on stdout: the exact and complete input handed to the
+check-authoring model. No model call, no network, deterministic.
+
+  {"spec_sha256": "<hex>", "inputs": [{"path", "sha256"}...], "prompt": "<text>"}
+
+Input selection mirrors the engine10 Wall (loki-ts/src/features/wall_manifest_wire.ts,
+the manifest builder wallManifestFor) and is deliberately narrower: of the files
+the Wall manifest reads, only the CONFIG class (runner and project config, same
+regex as CONFIG there, applied anchored to the whole repo-relative path, so
+only root-level config files qualify) is kept. Files come from git ls-files
+(tracked regular files, no symlinks), never a filesystem walk, so untracked and
+ignored files cannot reach the author. A non-git --repo fails closed: spec only.
+Same MAX_BLOB size cap and control-character path rule as the Wall. The Wall's
+other two classes are implementation-bearing and are excluded here: TESTISH test
+sources (style examples) and "named" source files (signatures of files the task
+names). Anything outside the spec and CONFIG files never reaches the author.
+"""
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+
+# Mirrors CONFIG, MAX_BLOB, MAX_FILES in wall_manifest_wire.ts.
+CONFIG = re.compile(
+    r"^(package\.json|bunfig\.toml|(vitest|jest)\.config\.[cm]?[jt]s|pytest\.ini|"
+    r"pyproject\.toml|setup\.cfg|tox\.ini|go\.mod|Cargo\.toml)$"
+)
+MAX_BLOB = 200_000
+MAX_FILES = 300
+# Mirrors TESTISH in wall_manifest_wire.ts.
+TESTISH = re.compile(r"(^|/)(tests?|__tests__|spec)/|\.(test|spec)\.[jt]sx?$|(^|/)test_[^/]*\.py$|_test\.(py|go)$")
+CTRL = re.compile(r"[\x00-\x1f\x7f]")
+
+PROMPT_HEAD = (
+    "You are the acceptance check author. You see only the specification and the "
+    "project's runner configuration below. You cannot see the implementation. "
+    "Write acceptance checks that prove the specification is met."
+)
+
+
+def sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def read_bytes(path: str) -> bytes:
+    with open(path, "rb") as fh:
+        return fh.read()
+
+
+def config_files(repo: str, spec_real: str):
+    found = []
+    for rel in tracked_regular_files(repo) or []:
+        # Anchored CONFIG against the whole repo-relative path, as the Wall does
+        # (CONFIG.test(e.path)): only root-level config files qualify.
+        if not CONFIG.match(rel) or TESTISH.search(rel) or CTRL.search(rel):
+            continue
+        full = os.path.join(repo, rel)
+        if os.path.islink(full) or not os.path.isfile(full) or os.path.realpath(full) == spec_real:
+            continue
+        try:
+            if os.path.getsize(full) > MAX_BLOB:
+                continue
+        except OSError:
+            continue
+        found.append((rel, full))
+        if len(found) >= MAX_FILES:
+            break
+    return found
+
+
+def tracked_regular_files(repo: str):
+    """git ls-files regular blobs (modes 100644/100755), like the Wall's ls-tree
+    read. None when repo is not a git repo or git fails: the caller fails closed."""
+    # Hardening mirrors SAFE_GIT_CONFIG in loki-ts/src/util/safe_git.ts: a repo-planted
+    # fsmonitor, hook or ssh command must never run, and a caller GIT_DIR must not
+    # redirect the listing.
+    env = {k: v for k, v in os.environ.items() if k not in ("GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE")}
+    env["GIT_CONFIG_NOSYSTEM"] = "1"
+    try:
+        r = subprocess.run(["git", "-c", "core.fsmonitor=", "-c", "core.hooksPath=/dev/null",
+                            "-c", "core.sshCommand=", "-c", "protocol.ext.allow=never",
+                            "-C", repo, "--no-replace-objects", "ls-files", "-s", "-z"],
+                           capture_output=True, timeout=10, check=False, env=env)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if r.returncode != 0:
+        return None
+    out = []
+    for raw in r.stdout.split(b"\0"):
+        if not raw:
+            continue
+        meta, _, path = raw.partition(b"\t")
+        if meta.split(b" ")[0] not in (b"100644", b"100755"):
+            continue
+        try:
+            out.append(path.decode("utf-8"))
+        except UnicodeDecodeError:
+            continue
+    return out
+
+
+def build_context(spec: str, repo: str) -> dict:
+    spec_bytes = read_bytes(spec)
+    spec_real = os.path.realpath(spec)
+    repo_real = os.path.realpath(repo)
+    if spec_real.startswith(repo_real + os.sep):
+        spec_path = os.path.relpath(spec_real, repo_real).replace(os.sep, "/")
+    else:
+        spec_path = spec_real
+    inputs = [{"path": spec_path, "sha256": sha256(spec_bytes)}]
+    parts = [PROMPT_HEAD, "Specification (%s):\n%s" % (spec_path, spec_bytes.decode("utf-8", "replace"))]
+    for rel, full in config_files(repo, spec_real):
+        data = read_bytes(full)
+        inputs.append({"path": rel, "sha256": sha256(data)})
+        parts.append("Runner config (%s):\n%s" % (rel, data.decode("utf-8", "replace")))
+    return {"spec_sha256": inputs[0]["sha256"], "inputs": inputs, "prompt": "\n\n".join(parts)}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="check_author.py")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    c = sub.add_parser("context", help="print the exact check-author input as JSON")
+    c.add_argument("--spec", required=True)
+    c.add_argument("--repo", required=True)
+    args = ap.parse_args(argv)
+    if not os.path.isfile(args.spec):
+        print("check_author: spec not found: %s" % args.spec, file=sys.stderr)
+        return 2
+    if not os.path.isdir(args.repo):
+        print("check_author: repo not a directory: %s" % args.repo, file=sys.stderr)
+        return 2
+    json.dump(build_context(args.spec, args.repo), sys.stdout, sort_keys=True)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/autonomy/lib/claude-flags.sh

@@ -38,8 +38,12 @@ loki_effort_for_tier() {
         cheap)       effort="low" ;;
         *)           effort="high" ;;
     esac
+    # LOKI_EFFORT is the one cross-provider knob: an explicit level replaces the tier-derived one
+    # (no complexity bump) and is still clamped to the model's catalog levels below.
+    local explicit=""
+    case "${LOKI_EFFORT:-}" in low|medium|high|xhigh|max) effort="$LOKI_EFFORT"; explicit=1 ;; esac
     # Complex projects get one bump up. "max" is the ceiling and only for explicit user override (not auto-bumped to from xhigh).
-    if [ "$complexity" = "complex" ]; then
+    if [ "$complexity" = "complex" ] && [ -z "$explicit" ]; then
         case "$effort" in
             low)    effort="medium" ;;
             medium) effort="high" ;;

package/autonomy/lib/mcp-config.sh

@@ -59,6 +59,37 @@ __LOKI_MCP_CONFIG_SH_LOADED=1
 # stdio MCP server backed by `python3 -m mcp.server`. Caller may extend
 # this in the future without API breakage; consumers should treat the
 # bundle as opaque JSON.
+# Remove stale temp files left by a writer killed between temp write and rename.
+# Mirrors sweepStaleTmp in loki-ts/src/util/atomic.ts. A temp is
+# removed only when it is named mcp-config.json.tmp.<pid>, is a regular file
+# (not a symlink) in the same directory, is owned by the current uid, is not
+# ours, and either its pid is dead or it is older than 60 minutes (pid reuse).
+_loki_mcp_sweep_stale_tmp() {
+    local dir="$1" f base pid sig alive
+    # Iterate the glob, never find output: a filename holding a newline must
+    # stay ONE entry, not become a second cwd-relative path.
+    for f in "$dir"/mcp-config.json.tmp.*; do
+        [ -L "$f" ] && continue
+        [ -f "$f" ] && [ -O "$f" ] || continue
+        base="${f##*/}"
+        pid="${base#mcp-config.json.tmp.}"
+        case "$pid" in '' | *[!0-9]*) continue ;; esac
+        [ "$pid" = "$$" ] && continue
+        alive=0
+        if sig="$(LC_ALL=C kill -0 "$pid" 2>&1)"; then
+            alive=1
+        else
+            # EPERM means the process exists under another uid: alive, as in the TS route.
+            case "$sig" in *"not permitted"*) alive=1 ;; esac
+        fi
+        if [ "$alive" = 1 ]; then
+            # Live pid: keep unless older than 60 minutes.
+            [ -n "$(find "$f" -maxdepth 0 -mmin +60 2>/dev/null)" ] || continue
+        fi
+        rm -f -- "$f" 2>/dev/null
+    done
+}
+
 loki_mcp_config_path() {
     local base="${TARGET_DIR:-.}"
     local mcp_dir="${base}/.loki"
@@ -88,7 +119,9 @@ loki_mcp_config_path() {
     # This makes the helper idempotent: identical bundle bytes -> no write,
     # mtime stable. python3 is used so JSON encoding is canonical.
     local tmp_bundle
+    _loki_mcp_sweep_stale_tmp "$mcp_dir"
     tmp_bundle="${mcp_path}.tmp.$$"
+    rm -f -- "$tmp_bundle" 2>/dev/null  # our pid left over from a reused pid
     if ! _MCP_OUT="$tmp_bundle" _MCP_LSP="$lsp_detected" python3 -c "
 import json, os
 out = os.environ['_MCP_OUT']
@@ -105,13 +138,20 @@ if lsp:
         'args': ['-m', 'mcp.lsp_proxy'],
     }
 bundle = {'mcpServers': servers}
-with open(out, 'w') as f:
+# O_EXCL|O_NOFOLLOW, 0600: never write through a planted symlink or file.
+fd = os.open(out, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, 'O_NOFOLLOW', 0), 0o600)
+with os.fdopen(fd, 'w') as f:
     json.dump(bundle, f, indent=2)
 " 2>/dev/null; then
         rm -f "$tmp_bundle" 2>/dev/null
         return 1
     fi
 
+    # Test hook, test-mode only (LOKI_TEST): die between the temp write and the rename.
+    if [ -n "${LOKI_TEST:-}" ] && [ "${LOKI_TEST_DIE_AFTER_MCP_TMP:-}" = "1" ]; then
+        kill -9 $$
+    fi
+
     # Idempotent write: only replace the file when bytes differ. cmp -s
     # exits 0 when identical, so we keep the existing file in that case.
     if [ -f "$mcp_path" ] && cmp -s "$tmp_bundle" "$mcp_path" 2>/dev/null; then

package/autonomy/lib/proof-analytics-props.py

@@ -2,7 +2,6 @@
 """Emit the FIXED analytics allowlist from a finished proof.json as key=value
 lines, one per line, for loki_emit_build_verified (autonomy/telemetry.sh).
 
-This is the SINGLE authoritative allowlist for opt-in build-outcome analytics.
 Only already-computed scalars are ever emitted -- never code, spec/PRD text,
 paths, or file names. Anything not named here is never read, so a proof.json
 schema change cannot silently start leaking a new field.
@@ -12,16 +11,124 @@ Free-text-shaped fields are excluded on purpose:
     computed deterministically from facts -- never spec/project text.
   - files_changed is emitted as a COUNT only, never the paths list.
 
+The allowlist of keys, types, ranges and enums is NOT defined here. It lives in
+autonomy/lib/telemetry-schema.json, the one schema shared with
+autonomy/telemetry.sh and dashboard/telemetry.py. This file only maps proof.json
+fields to schema keys and applies the schema (`sanitize`).
+
 Usage: proof-analytics-props.py <proof.json>
+       proof-analytics-props.py --payload <event> <distinct_id> <api_key> [k=v ...]
+         prints the final capture body for the bash sender after schema
+         filtering; prints nothing and exits non-zero for an event the schema
+         does not list.
 Fail-open: any error prints nothing and exits non-zero; the caller drops it.
 """
 import json
+import math
+import os
+import re
 import sys
 
+SCHEMA_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "telemetry-schema.json")
+_SEMVER = re.compile(r"^\d{1,6}\.\d{1,6}\.\d{1,6}(-[0-9A-Za-z.]{1,24})?$")
+_INT = re.compile(r"^-?\d{1,12}$")
+
+
+def load_schema(path=None):
+    with open(path or SCHEMA_PATH) as f:
+        return json.load(f)
+
+
+def _coerce(spec, v):
+    """Return (ok, value). A value that fails its spec is dropped, never forwarded."""
+    t = spec.get("type")
+    if t == "bool":
+        if isinstance(v, bool):
+            return True, v
+        if isinstance(v, str) and v in ("true", "false"):
+            return True, v == "true"
+        return False, None
+    if t == "enum":
+        if not isinstance(v, str):
+            return False, None
+        if spec.get("fold") == "upper":
+            v = v.upper()
+        return (v in spec["values"]), v
+    if t == "int":
+        if isinstance(v, bool):
+            return False, None
+        if isinstance(v, int):
+            n = v
+        elif isinstance(v, str) and _INT.match(v):
+            n = int(v)
+        else:
+            return False, None
+        return (spec["min"] <= n <= spec["max"]), n
+    if t == "number":
+        if isinstance(v, bool):
+            return False, None
+        if isinstance(v, str) and len(v) > 24:
+            return False, None
+        try:
+            n = float(v)
+        except (TypeError, ValueError):
+            return False, None
+        if not math.isfinite(n):
+            return False, None
+        return (spec["min"] <= n <= spec["max"]), n
+    if t == "semver":
+        return (isinstance(v, str) and bool(_SEMVER.match(v))), v
+    return False, None
+
+
+def sanitize(schema, event, props):
+    """Return the filtered property dict, or None when the event is not listed."""
+    if not isinstance(event, str) or event not in schema["events"]:
+        return None
+    specs = dict(schema["common"])
+    specs.update(schema["events"][event])
+    out = {}
+    for k, v in (props or {}).items():
+        spec = specs.get(k) if isinstance(k, str) else None
+        if spec is None:
+            continue
+        ok, val = _coerce(spec, v)
+        if ok:
+            out[k] = val
+    # Every event carries the flag; events with no command source are False.
+    src = schema.get("introspective_source", {}).get(event)
+    out["introspective"] = bool(src) and out.get(src) in schema["introspective_commands"]
+    return out
+
+
+def payload_main(argv):
+    """argv: event distinct_id api_key [k=v ...]. Later pairs win, so the trusted
+    base properties the shell appends last cannot be overridden by a caller."""
+    if len(argv) < 3:
+        return 1
+    event, distinct_id, api_key = argv[0], argv[1], argv[2]
+    raw = {}
+    for arg in argv[3:]:
+        if "=" in arg:
+            k, v = arg.split("=", 1)
+            raw[k] = v
+    props = sanitize(load_schema(), event, raw)
+    if props is None:
+        return 1
+    sys.stdout.write(json.dumps({
+        "api_key": api_key,
+        "event": event,
+        "distinct_id": distinct_id,
+        "properties": props,
+    }))
+    return 0
+
 
 def main():
     if len(sys.argv) < 2:
         return 1
+    if sys.argv[1] == "--payload":
+        return payload_main(sys.argv[2:])
     try:
         p = json.load(open(sys.argv[1]))
     except Exception:
@@ -55,15 +162,17 @@ def main():
         "gates_total": gates_total,
         "gate_pass_rate": rate,
     }
+    out = {k: v for k, v in out.items() if v is not None and v != ""}
+    out = sanitize(load_schema(), "build_verified", out) or {}
 
     for k, v in out.items():
-        if v is None or v == "":
-            continue
-        # key=value; sanitize so a value can never inject a second pair or a newline.
-        v = str(v).replace("\n", " ").replace("=", "-")
+        # key=value; the schema already rejected anything with newline or "=".
         sys.stdout.write("%s=%s\n" % (k, v))
     return 0
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    try:
+        sys.exit(main())
+    except Exception:
+        sys.exit(1)

package/autonomy/lib/proof-verify.py

@@ -578,6 +578,24 @@ class ProofLoadError(Exception):
     """Raised for a missing file / malformed JSON / unusable proof shape."""
 
 
+MAX_PROOF_DEPTH = 256  # mirrors MAX_RECEIPT_DEPTH in loki-ts verify_cmd.ts; real proofs are under 20 deep
+
+
+def _too_deep(data):
+    """Iterative nesting check, so every interpreter version gives the same answer."""
+    stack = [(data, 1)]
+    while stack:
+        node, depth = stack.pop()
+        if not isinstance(node, (dict, list)):
+            continue
+        if depth > MAX_PROOF_DEPTH:
+            return True
+        for child in (node.values() if isinstance(node, dict) else node):
+            if isinstance(child, (dict, list)):
+                stack.append((child, depth + 1))
+    return False
+
+
 def _load_proof(proof_path):
     if not os.path.isfile(proof_path):
         raise ProofLoadError("proof file not found: %s" % proof_path)
@@ -586,10 +604,14 @@ def _load_proof(proof_path):
             data = json.load(f)
     except json.JSONDecodeError as exc:
         raise ProofLoadError("malformed JSON in %s: %s" % (proof_path, exc))
+    except RecursionError:
+        raise ProofLoadError("proof nested too deeply: %s" % proof_path)
     except OSError as exc:
         raise ProofLoadError("could not read %s: %s" % (proof_path, exc))
     if not isinstance(data, dict):
         raise ProofLoadError("proof root is not a JSON object: %s" % proof_path)
+    if _too_deep(data):
+        raise ProofLoadError("proof nested too deeply: %s" % proof_path)
     return data
 
 

package/autonomy/lib/telemetry-schema.json

@@ -0,0 +1,52 @@
+{
+ "_comment": "Single allowlist for every telemetry sender (autonomy/telemetry.sh, dashboard/telemetry.py, autonomy/lib/proof-analytics-props.py). An event not listed here is never sent. A key not listed is dropped. A value outside its type, range or enum is dropped. Documented in docs/PRIVACY.md.",
+ "schema_version": 1,
+ "common": {
+  "os_family": {"type": "enum", "values": ["linux", "darwin", "windows", "other"]},
+  "arch": {"type": "enum", "values": ["x64", "arm64", "other"]},
+  "version": {"type": "semver"},
+  "channel": {"type": "enum", "values": ["npm", "docker", "homebrew", "skill", "source", "unknown"]},
+  "traffic": {"type": "enum", "values": ["user", "ci", "internal"]},
+  "introspective": {"type": "bool"}
+ },
+ "introspective_commands": ["--help", "--version", "-h", "-v", "completion", "completions", "help", "internal", "memory", "version"],
+ "introspective_source": {"cli_command": "command", "installed": "first_command"},
+ "events": {
+  "installed": {
+   "first_command": {"type": "enum", "values": ["--help", "--version", "-h", "-v", "agent", "analyze", "api", "assets", "audit", "bench", "checkpoint", "ci", "cleanup", "cluster", "cockpit", "code", "completion", "completions", "compliance", "compound", "config", "context", "control", "cost", "council", "cp", "crash", "ctx", "dashboard", "demo", "deploy", "docker", "docs", "doctor", "dogfood", "enterprise", "explain", "export", "factory", "failover", "github", "grill", "handoff", "heal", "help", "import", "init", "internal", "issue", "kpis", "logs", "magic", "mcp", "memory", "metrics", "migrate", "modernize", "monitor", "next", "notify", "onboard", "open", "optimize", "otel", "own", "pause", "plan", "preview", "projects", "proof", "provider", "quick", "quickstart", "rc", "receipt", "remote", "report", "reset", "resume", "review", "rollback", "run", "sandbox", "secrets", "secure", "self_update", "self-update", "sentrux", "serve", "setup-skill", "share", "ship", "spec", "start", "state", "stats", "status", "steer", "stop", "syslog", "telemetry", "template", "test", "tour", "trigger", "trust", "trust-metrics", "ultracode", "update", "verify", "version", "voice", "watch", "watchdog", "web", "welcome", "why", "wiki", "worktree", "wow", "wt", "other"]}
+  },
+  "cli_command": {
+   "command": {"type": "enum", "values": ["--help", "--version", "-h", "-v", "agent", "analyze", "api", "assets", "audit", "bench", "checkpoint", "ci", "cleanup", "cluster", "cockpit", "code", "completion", "completions", "compliance", "compound", "config", "context", "control", "cost", "council", "cp", "crash", "ctx", "dashboard", "demo", "deploy", "docker", "docs", "doctor", "dogfood", "enterprise", "explain", "export", "factory", "failover", "github", "grill", "handoff", "heal", "help", "import", "init", "internal", "issue", "kpis", "logs", "magic", "mcp", "memory", "metrics", "migrate", "modernize", "monitor", "next", "notify", "onboard", "open", "optimize", "otel", "own", "pause", "plan", "preview", "projects", "proof", "provider", "quick", "quickstart", "rc", "receipt", "remote", "report", "reset", "resume", "review", "rollback", "run", "sandbox", "secrets", "secure", "self_update", "self-update", "sentrux", "serve", "setup-skill", "share", "ship", "spec", "start", "state", "stats", "status", "steer", "stop", "syslog", "telemetry", "template", "test", "tour", "trigger", "trust", "trust-metrics", "ultracode", "update", "verify", "version", "voice", "watch", "watchdog", "web", "welcome", "why", "wiki", "worktree", "wow", "wt", "other"]}
+  },
+  "session_start": {
+   "provider": {"type": "enum", "values": ["claude", "codex", "cline", "aider", "opencode"]},
+   "complexity": {"type": "enum", "values": ["simple", "standard", "complex"]},
+   "parallel": {"type": "bool"}
+  },
+  "session_end": {
+   "provider": {"type": "enum", "values": ["claude", "codex", "cline", "aider", "opencode"]},
+   "duration": {"type": "int", "min": 0, "max": 31536000},
+   "iterations": {"type": "int", "min": 0, "max": 100000},
+   "result": {"type": "int", "min": 0, "max": 255}
+  },
+  "dashboard_start": {},
+  "first_start_attempted": {
+   "entry": {"type": "enum", "values": ["--help", "--version", "-h", "-v", "agent", "analyze", "api", "assets", "audit", "bench", "checkpoint", "ci", "cleanup", "cluster", "cockpit", "code", "completion", "completions", "compliance", "compound", "config", "context", "control", "cost", "council", "cp", "crash", "ctx", "dashboard", "demo", "deploy", "docker", "docs", "doctor", "dogfood", "enterprise", "explain", "export", "factory", "failover", "github", "grill", "handoff", "heal", "help", "import", "init", "internal", "issue", "kpis", "logs", "magic", "mcp", "memory", "metrics", "migrate", "modernize", "monitor", "next", "notify", "onboard", "open", "optimize", "otel", "own", "pause", "plan", "preview", "projects", "proof", "provider", "quick", "quickstart", "rc", "receipt", "remote", "report", "reset", "resume", "review", "rollback", "run", "sandbox", "secrets", "secure", "self_update", "self-update", "sentrux", "serve", "setup-skill", "share", "ship", "spec", "start", "state", "stats", "status", "steer", "stop", "syslog", "telemetry", "template", "test", "tour", "trigger", "trust", "trust-metrics", "ultracode", "update", "verify", "version", "voice", "watch", "watchdog", "web", "welcome", "why", "wiki", "worktree", "wow", "wt", "other"]}
+  },
+  "first_run_blocked": {
+   "blocker": {"type": "enum", "values": ["no_provider", "not_logged_in", "not_a_repo", "git_identity", "node", "python3", "jq", "git", "curl", "disk", "skill_symlink", "other"]}
+  },
+  "build_verified": {
+   "headline": {"type": "enum", "values": ["VERIFIED", "VERIFIED WITH GAPS", "NOT VERIFIED"]},
+   "route": {"type": "enum", "values": ["engine10"]},
+   "evidence_gate_verdict": {"type": "enum", "fold": "upper", "values": ["PASS", "BLOCK"]},
+   "final_verdict": {"type": "enum", "fold": "upper", "values": ["APPROVED", "REJECTED", "APPROVE", "REJECT", "COMPLETE", "CONTINUE"]},
+   "iterations": {"type": "int", "min": 0, "max": 100000},
+   "files_changed_count": {"type": "int", "min": 0, "max": 10000000},
+   "wall_clock_sec": {"type": "number", "min": 0, "max": 31536000},
+   "gates_passed": {"type": "int", "min": 0, "max": 1000},
+   "gates_total": {"type": "int", "min": 0, "max": 1000},
+   "gate_pass_rate": {"type": "number", "min": 0, "max": 1}
+  }
+ }
+}