loki-mode 11.4.2 → 11.5.1

package/packages/control-plane/dist/server.js

@@ -311,8 +311,10 @@ function verifyRunPid(runDir, runId, startOf = processStartTime) {
     return { ok: false, reason: "the pid now belongs to a different process (start time differs)" };
   return { ok: true, pid: rec.pid };
 }
-var runPidPath = (runDir) => join8(runDir, "run.pid");
-var init_run_pid = () => {};
+var runPidPath = (runDir) => join8(runDir, "run.pid"), liveSessions;
+var init_run_pid = __esm(() => {
+  liveSessions = new Set;
+});
 
 // src/shipper/watch.ts
 import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync } from "fs";
@@ -7324,6 +7326,18 @@ var init_paths = __esm(() => {
 });
 
 // ../../loki-ts/src/engine10/types.ts
+function pushArgv(a) {
+  switch (a.cmd) {
+    case "push-pr":
+      return ["push-pr", a.repoDir, a.branch, a.title, a.bodyFile, a.draft ? "1" : "0"];
+    case "comment":
+      return ["comment", a.runId, a.prUrl, a.file];
+    case "status":
+      return ["status", a.sha, a.state, a.description];
+    case "issue-comment":
+      return ["issue-comment", a.issueRef, a.bodyFile];
+  }
+}
 function taskBlock(task) {
   return ["Task (untrusted, quoted verbatim):", "<<<TASK", task, "TASK"];
 }
@@ -9310,6 +9324,17 @@ var init_cost = __esm(() => {
 import { existsSync as existsSync18, mkdirSync as mkdirSync8, readdirSync as readdirSync11, readFileSync as readFileSync23, renameSync as renameSync4, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname10, join as join31, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+function loadDefaultMaxCostUsd() {
+  const here = dirname10(fileURLToPath2(import.meta.url));
+  for (const rel of [["..", "..", "data"], ["..", "data"]]) {
+    try {
+      const j = JSON.parse(readFileSync23(resolve10(here, ...rel, "model-pricing.json"), "utf8"));
+      if (typeof j.default_max_cost_usd === "number" && Number.isFinite(j.default_max_cost_usd) && j.default_max_cost_usd > 0)
+        return j.default_max_cost_usd;
+    } catch {}
+  }
+  return DEFAULT_FALLBACK_USD;
+}
 function _loadPricing() {
   try {
     const moduleDir = dirname10(fileURLToPath2(import.meta.url));
@@ -9344,7 +9369,7 @@ function _loadPricing() {
     return _FALLBACK_PRICING;
   }
 }
-var _FALLBACK_PRICING, PRICING;
+var DEFAULT_FALLBACK_USD = 100, _FALLBACK_PRICING, PRICING;
 var init_budget = __esm(() => {
   init_paths();
   init_cost();
@@ -9393,13 +9418,37 @@ var init_session_route = __esm(() => {
 });
 
 // ../../loki-ts/src/providers/provider_guard.ts
+function providerSandboxFlags(provider) {
+  switch (provider) {
+    case "codex":
+      return ["--sandbox", "workspace-write"];
+    case "aider":
+      return ["--no-auto-commits"];
+    default:
+      return [];
+  }
+}
+var E10_COMMON = "loki-ts/src/engine10/session.ts (detached spawn, killGroupWithGrace, recordCost, watchBudget), loki-ts/src/providers/provider_guard.ts, loki-ts/src/e10ext/budget_cap.ts", U = "unknown", CAPABILITIES;
 var init_provider_guard = __esm(() => {
   init_safe_git();
+  CAPABILITIES = [
+    { provider: "claude", engine: "engine10", invocation: "Agent SDK query() (default) or claude CLI via loki-ts/src/runner/providers.ts", cost: "measured", budgetKill: "post-iteration", cancelProcessGroup: "yes", sandboxFlags: [], receipt: "yes", resume: "yes", guardScan: "native", killBlocking: "native", source: `${E10_COMMON}; loki-ts/src/runner/providers.ts (LOKI_E10_RESUME_SESSION, claude only)` },
+    { provider: "codex", engine: "engine10", invocation: "codex exec --sandbox workspace-write --skip-git-repo-check", cost: "estimated", budgetKill: "post-iteration", cancelProcessGroup: "yes", sandboxFlags: providerSandboxFlags("codex"), receipt: "yes", resume: "no", guardScan: "post-iteration", killBlocking: "none", source: `${E10_COMMON}; loki-ts/src/providers/provider_cost.ts (ESTIMATED_PROVIDERS); loki-ts/src/runner/providers.ts codexProvider` },
+    { provider: "cline", engine: "engine10", invocation: "cline -y", cost: "estimated", budgetKill: "post-iteration", cancelProcessGroup: "yes", sandboxFlags: providerSandboxFlags("cline"), receipt: "yes", resume: "no", guardScan: "post-iteration", killBlocking: "none", source: `${E10_COMMON}; loki-ts/src/providers/provider_cost.ts; providers/cline.sh` },
+    { provider: "aider", engine: "engine10", invocation: "aider --yes-always", cost: "estimated", budgetKill: "post-iteration", cancelProcessGroup: "yes", sandboxFlags: providerSandboxFlags("aider"), receipt: "yes", resume: "no", guardScan: "post-iteration", killBlocking: "none", source: `${E10_COMMON}; loki-ts/src/providers/provider_cost.ts (a reported "Cost: $X session" line is used as-is); providers/aider.sh` },
+    { provider: "opencode", engine: "engine10", invocation: "opencode run --auto [-m provider/model]", cost: "none", budgetKill: "none", cancelProcessGroup: "yes", sandboxFlags: providerSandboxFlags("opencode"), receipt: "yes", resume: "no", guardScan: "post-iteration", killBlocking: "none", source: `${E10_COMMON}; loki-ts/src/runner/provider_opencode.ts (costMeasured false); loki-ts/src/providers/provider_cost.ts (opencode not in ESTIMATED_PROVIDERS); docs/v10/GUIDE.md provider table` },
+    { provider: "claude", engine: "legacy", invocation: "claude --dangerously-skip-permissions (bash loop)", cost: U, budgetKill: U, cancelProcessGroup: U, sandboxFlags: U, receipt: U, resume: U, guardScan: U, killBlocking: U, source: "providers/claude.sh (PROVIDER_AUTONOMOUS_FLAG); autonomy/run.sh (LOKI_BUDGET_LIMIT); other fields not confirmed" },
+    { provider: "codex", engine: "legacy", invocation: "codex exec --sandbox workspace-write --skip-git-repo-check (bash loop)", cost: U, budgetKill: U, cancelProcessGroup: U, sandboxFlags: ["--sandbox", "workspace-write"], receipt: U, resume: U, guardScan: U, killBlocking: U, source: "providers/codex.sh (PROVIDER_AUTONOMOUS_FLAG); other fields not confirmed" },
+    { provider: "cline", engine: "legacy", invocation: "cline -y (bash loop)", cost: U, budgetKill: U, cancelProcessGroup: U, sandboxFlags: U, receipt: U, resume: U, guardScan: U, killBlocking: U, source: "providers/cline.sh (PROVIDER_AUTONOMOUS_FLAG); other fields not confirmed" },
+    { provider: "aider", engine: "legacy", invocation: "aider --yes-always (bash loop)", cost: U, budgetKill: U, cancelProcessGroup: U, sandboxFlags: U, receipt: U, resume: U, guardScan: U, killBlocking: U, source: "providers/aider.sh (PROVIDER_AUTONOMOUS_FLAG); other fields not confirmed" },
+    { provider: "opencode", engine: "legacy", invocation: "opencode run --auto (bash loop)", cost: U, budgetKill: U, cancelProcessGroup: U, sandboxFlags: U, receipt: U, resume: U, guardScan: U, killBlocking: U, source: "providers/opencode.sh (PROVIDER_AUTONOMOUS_FLAG); other fields not confirmed" }
+  ];
 });
 
 // ../../loki-ts/src/engine10/session.ts
 var STDERR_TAIL_BYTES, ADVISOR_MARKED_STAGES;
 var init_session = __esm(() => {
+  init_run_pid();
   init_provider_cost();
   init_model_routes();
   init_cost();
@@ -10129,8 +10178,39 @@ var init_runner_errors = __esm(() => {
   ];
 });
 
+// ../../loki-ts/src/engine10/testmap.ts
+import { basename as basename12, extname, join as join38, relative as relative3, sep as sep10 } from "path";
+function isTestFile(rel) {
+  const name = basename12(rel);
+  return JS_TEST_RE.test(name) || PY_TEST_RE.test(name) || GO_TEST_RE.test(name);
+}
+var SKIP_DIRS, JS_TEST_RE, PY_TEST_RE, GO_TEST_RE;
+var init_testmap = __esm(() => {
+  init_resolve();
+  init_scope();
+  SKIP_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "target",
+    "coverage",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".tox",
+    ".pytest_cache",
+    ".loki",
+    ".next"
+  ]);
+  JS_TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+  PY_TEST_RE = /^(test_.+|.+_test)\.py$/;
+  GO_TEST_RE = /_test\.go$/;
+});
+
 // ../../loki-ts/src/util/check_result.ts
-import { basename as basename12 } from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync28, renameSync as renameSync5, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename13, join as join39 } from "path";
 function plainTestEnv(base = process.env) {
   const e = {};
   for (const [k, v] of Object.entries(tokenFreeEnv(base)))
@@ -10148,7 +10228,7 @@ function ran(raw2, path, ok) {
   if (blk) {
     const c = n2(blk, /(?:#|\u2139) pass (\d+)/) + n2(blk, /(?:#|\u2139) fail (\d+)/);
     const nm = out2.match(/^(?:ok \d+ - |\u2714 )(\S+\.[cm]?[jt]s)(?: \(|$)/m)?.[1];
-    return c === 1 && nm && (!path || basename12(nm) === basename12(path)) ? 0 : c;
+    return c === 1 && nm && (!path || basename13(nm) === basename13(path)) ? 0 : c;
   }
   const cg = cargoTrailer(out2);
   if (cg.length)
@@ -10239,16 +10319,16 @@ function goRunner(cmd, args) {
     let k = 0;
     for (;k < t.length; k++) {
       const x = t[k];
-      if (/^[A-Za-z_]\w*=/.test(x) || /^(?:env|command|exec|time|nohup)$/.test(basename12(x)))
+      if (/^[A-Za-z_]\w*=/.test(x) || /^(?:env|command|exec|time|nohup)$/.test(basename13(x)))
         continue;
-      if (/^-/.test(x) && k > 0 && basename12(t[k - 1]) === "env") {
+      if (/^-/.test(x) && k > 0 && basename13(t[k - 1]) === "env") {
         if (x === "-u" || x === "-C" || x === "-S")
           k++;
         continue;
       }
       break;
     }
-    if (t[k] !== undefined && basename12(t[k]) === "go")
+    if (t[k] !== undefined && basename13(t[k]) === "go")
       return { runner: "go" };
   }
   return {};
@@ -10329,31 +10409,163 @@ function classifyCheck(i) {
     return { result: "not_run", reason: UNMEASURED_REASON };
   return { result: "pass", n: n2 };
 }
+function summaryOf(a) {
+  const why = a.tier === a.computed ? a.reasons.slice(0, 2).join("; ") : `computed ${a.computed}; override ${a.override?.from} to ${a.override?.to}: ${a.override?.reason}`;
+  const def = a.checks_deferred;
+  return `risk: ${a.tier} (${why}), ${def.length ? def.join(", ") : "no deeper checks"} not run`;
+}
+function markExecuted(a, executed) {
+  const checks_deferred = deferredOf(a.tier, a.checks_selected, executed);
+  return { ...a, checks_deferred, summary: summaryOf({ ...a, checks_deferred }) };
+}
+function classifyRisk(files, env = process.env) {
+  const lines = files.reduce((n2, f) => n2 + f.added + f.deleted, 0);
+  const sensitive = files.flatMap((f) => {
+    const hit = SENSITIVE.find(([, re]) => re.test(f.path));
+    return hit && !isTestFile(f.path) ? [`${f.path} (${hit[0]})`] : [];
+  });
+  const testFiles = files.filter((f) => isTestFile(f.path));
+  const testsDeleted = testFiles.filter((f) => f.status === "deleted").map((f) => f.path);
+  const testsModified = [...testFiles.filter((f) => f.status !== "added" && f.status !== "deleted").map((f) => f.path), ...files.filter((f) => TEST_CFG.test(f.path)).map((f) => f.path)];
+  const api = files.filter((f) => API.test(f.path) && !isTestFile(f.path)).map((f) => f.path);
+  const high = [], med = [];
+  if (sensitive.length)
+    high.push(`sensitive paths: ${sensitive.slice(0, 5).join(", ")}${sensitive.length > 5 ? ` (+${sensitive.length - 5})` : ""}`);
+  if (testsDeleted.length)
+    high.push(`test files deleted: ${testsDeleted.join(", ")}`);
+  if (api.length)
+    high.push(`public API surface: ${api.slice(0, 3).join(", ")}`);
+  if (files.length >= FILES_HIGH)
+    high.push(`${files.length} files >= ${FILES_HIGH}`);
+  if (lines >= LINES_HIGH)
+    high.push(`${lines} changed lines >= ${LINES_HIGH}`);
+  if (testsModified.length)
+    med.push(`existing tests or test config modified: ${testsModified.slice(0, 3).join(", ")}`);
+  if (files.length >= FILES_MEDIUM)
+    med.push(`${files.length} files >= ${FILES_MEDIUM}`);
+  if (lines >= LINES_MEDIUM)
+    med.push(`${lines} changed lines >= ${LINES_MEDIUM}`);
+  const computed = high.length ? "high" : med.length ? "medium" : "low";
+  const reasons = high.length ? [...high, ...med] : med.length ? med : [`${files.length} file${files.length === 1 ? "" : "s"}, no sensitive paths`];
+  let tier = computed, override, ignored;
+  const asked = (env["LOKI_RISK_TIER"] ?? "").trim().toLowerCase();
+  if (asked in RANK2 && asked !== computed) {
+    const reason = (env["LOKI_RISK_OVERRIDE_REASON"] ?? "").trim();
+    if (RANK2[asked] > RANK2[computed]) {
+      tier = asked;
+      override = { from: computed, to: asked, reason: reason || "raised by LOKI_RISK_TIER" };
+    } else if (reason) {
+      tier = asked;
+      override = { from: computed, to: asked, reason };
+    } else
+      ignored = `LOKI_RISK_TIER=${asked} ignored: lowering from ${computed} needs LOKI_RISK_OVERRIDE_REASON`;
+  }
+  const plan = PLAN[tier], checks_deferred = deferredOf(tier, plan.selected, []);
+  const summary = summaryOf({ tier, computed, reasons, ...override ? { override } : {}, checks_deferred });
+  return {
+    version: 1,
+    tier,
+    computed,
+    reasons,
+    stats: { files: files.length, lines, sensitive, tests_modified: testsModified, tests_deleted: testsDeleted, api },
+    checks_selected: plan.selected,
+    checks_deferred,
+    ...override ? { override } : {},
+    ...ignored ? { override_ignored: ignored } : {},
+    summary
+  };
+}
+function changedFiles(repoDir, baseSha) {
+  const run = (args) => safeGit(repoDir, args).split(`
+`).map((l) => l.trim()).filter(Boolean);
+  const tracked = run(["diff", "--name-only", baseSha]);
+  const untracked = run(["ls-files", "--others", "--exclude-standard"]);
+  return [...new Set([...tracked, ...untracked])].filter((f) => !f.startsWith(".loki/"));
+}
+function diffFiles(repoDir, baseSha) {
+  const paths = changedFiles(repoDir, baseSha), stat = new Map;
+  for (const l of safeGit(repoDir, ["diff", "--numstat", baseSha]).split(`
+`)) {
+    const [a, d, ...p] = l.split("\t"), path = p.join("\t");
+    if (path)
+      stat.set(path, { path, added: Number(a) || 0, deleted: Number(d) || 0 });
+  }
+  for (const l of safeGit(repoDir, ["diff", "--name-status", baseSha]).split(`
+`)) {
+    const [s, ...p] = l.split("\t"), f = stat.get(p[p.length - 1] ?? "");
+    if (f)
+      f.status = s?.startsWith("A") ? "added" : s?.startsWith("D") ? "deleted" : "modified";
+  }
+  return paths.map((path) => {
+    const f = stat.get(path);
+    if (f)
+      return f;
+    let n2 = 0;
+    try {
+      n2 = readFileSync28(join39(repoDir, path), "utf8").split(`
+`).length;
+    } catch {}
+    return { path, added: n2, deleted: 0, status: "added" };
+  });
+}
+function recordRisk(repoDir, a) {
+  try {
+    const dir = join39(repoDir, ".loki", "state"), p = join39(dir, "risk-tier.json");
+    mkdirSync10(dir, { recursive: true });
+    writeFileSync13(`${p}.tmp`, JSON.stringify(a, null, 2) + `
+`);
+    renameSync5(`${p}.tmp`, p);
+    return p;
+  } catch {
+    return null;
+  }
+}
 var NO_TESTS_REASON = "no tests executed", GO_EXIT0_REASON = "test count could not be confirmed: go test output is produced by the code under test and cannot confirm execution (a Go exit 0 is never a pass)", UNCONFIRMED_REASON = "test count could not be confirmed", FAIL_EVIDENCE, GO_FAIL_EVIDENCE, UNMEASURED_REASON = "executed count unmeasured (Loki could not parse the runner summary, harness-owned)", stripAnsi = (s) => s.replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "").replace(/(?:\u001b\[|\u009b)[0-9;?]*[ -\/]*[@-~]/g, "").replace(/\r\n?/g, `
 `), tailLines = (out2) => out2.split(`
-`).filter((x) => x.trim()).slice(-12), GO_PKG_RE, isExecutedProof = (c) => c.result === "pass" && typeof c.n === "number" && c.n > 0, hasExecutedProof = (checks) => checks.some(isExecutedProof);
+`).filter((x) => x.trim()).slice(-12), GO_PKG_RE, isExecutedProof = (c) => c.result === "pass" && typeof c.n === "number" && c.n > 0, hasExecutedProof = (checks) => checks.some(isExecutedProof), SENSITIVE, API, TEST_CFG, RANK2, FILES_MEDIUM = 4, FILES_HIGH = 15, LINES_MEDIUM = 100, LINES_HIGH = 500, RAN_ALWAYS, PLAN, LOW_SKIPPED, deferredOf = (tier, selected, executed) => (tier === "low" ? LOW_SKIPPED : selected).filter((c) => !RAN_ALWAYS.includes(c) && !executed.includes(c));
 var init_check_result = __esm(() => {
+  init_testmap();
   init_safe_git();
   FAIL_EVIDENCE = /\[(?:build|setup) failed\]|^--- FAIL|^[\w./-]+\.go:\d+:\d+: \S|\b[1-9]\d* (?:failed|errors?)\b/m;
   GO_FAIL_EVIDENCE = /^FAIL\t\S+\t[\d.]+s$|^panic: /m;
   GO_PKG_RE = /^(?:ok|FAIL|\?)\s+\S+\s+(?:\(cached\)|[\d.]+s\b|\[(?:no test files|build failed|setup failed)\])/;
+  SENSITIVE = [
+    ["auth", /(^|\/)(auth|oauth|sso|session|login|permission|rbac|acl)[\w.-]*(\/|\.|$)/i],
+    ["crypto", /(^|\/)(crypt|crypto|jwt|signing|keys?|secrets?|tokens?|credential|password)[\w.-]*(\/|\.|$)/i],
+    ["payments", /(^|\/)(payments?|billing|checkout|stripe|invoice)[\w.-]*(\/|\.|$)/i],
+    ["migration", /(^|\/)(migrations?|alembic)\/|\.sql$/i],
+    ["ci", /(^|\/)(\.github\/(workflows|actions)|\.gitlab-ci\.yml|\.circleci|Jenkinsfile|azure-pipelines)/i],
+    ["lockfile", /(^|\/)(package-lock\.json|pnpm-lock\.yaml|bun\.lockb?|go\.sum|[\w-]+\.lock)$/],
+    ["infra", /(^|\/)(Dockerfile[\w.-]*|docker-compose[\w.-]*\.ya?ml|terraform|helm|k8s|kubernetes|infra|deploy)(\/|\.|$)|\.tf$/i],
+    ["env", /(^|\/)\.env[\w.]*$/]
+  ];
+  API = /(^|\/)(openapi|swagger)[\w.-]*\.(ya?ml|json)$|\.proto$|\.d\.ts$|(^|\/)(api|routes|public)\/|(^|\/)index\.(ts|js|py)$/i;
+  TEST_CFG = /(^|\/)(conftest\.py|\.?pytest\.(ini|toml)|tox\.ini|jest\.config\.[\w.]+|vitest\.config\.[\w.]+)$/;
+  RANK2 = { low: 0, medium: 1, high: 2 };
+  RAN_ALWAYS = ["targeted tests", "lint of changed files"];
+  PLAN = {
+    low: { selected: [...RAN_ALWAYS] },
+    medium: { selected: [...RAN_ALWAYS, "full test command", "one reviewer"] },
+    high: { selected: [...RAN_ALWAYS, "full test command", "full suite", "council", "security scan"] }
+  };
+  LOW_SKIPPED = ["full test command", "reviewer", "council", "security scan"];
 });
 
 // ../../loki-ts/src/runner/load_owner.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { mkdtempSync as mkdtempSync5, realpathSync as realpathSync15, rmSync as rmSync8 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { basename as basename13, extname, join as join38 } from "path";
+import { basename as basename14, extname as extname2, join as join40 } from "path";
 function changedFilesNamed(out2, repoDir, changed) {
   return changed.filter((f) => {
-    if (out2.includes(f) || out2.includes(join38(repoDir, f)))
+    if (out2.includes(f) || out2.includes(join40(repoDir, f)))
       return true;
     const segs = f.split("/");
     if (suffixes(segs, 2).some((x) => x !== f && bounded(out2, x, "(?![\\w-])")))
       return true;
-    if (extname(f) === ".go" && segs.length > 1 && suffixes(segs.slice(0, -1), 1).some((d) => new RegExp(`(?<=[\\w-])/${esc(d)}(?![\\w./-])`).test(out2)))
+    if (extname2(f) === ".go" && segs.length > 1 && suffixes(segs.slice(0, -1), 1).some((d) => new RegExp(`(?<=[\\w-])/${esc(d)}(?![\\w./-])`).test(out2)))
       return true;
-    const stem = basename13(f, extname(f));
+    const stem = basename14(f, extname2(f));
     if (stem.length < 2 || stem === "index" || stem === "__init__")
       return false;
     return new RegExp(`(?<![\\w-])${esc(stem)}(?![\\w-])`).test(out2);
@@ -10457,7 +10669,7 @@ async function loadErrorIsHarnessOwned(i) {
     return false;
   if (i.args.some((a) => changed.includes(a.replace(/^\.\//, ""))))
     return false;
-  const dir = mkdtempSync5(join38(tmpdir7(), "e10-loadown-"));
+  const dir = mkdtempSync5(join40(tmpdir7(), "e10-loadown-"));
   const git3 = (args) => {
     safeGit(i.repoDir, args, { stdio: "ignore" });
   };
@@ -10488,38 +10700,8 @@ var init_load_owner = __esm(() => {
   init_check_result();
 });
 
-// ../../loki-ts/src/engine10/testmap.ts
-import { basename as basename14, extname as extname2, join as join39, relative as relative3, sep as sep10 } from "path";
-function isTestFile(rel) {
-  const name = basename14(rel);
-  return JS_TEST_RE.test(name) || PY_TEST_RE.test(name) || GO_TEST_RE.test(name);
-}
-var SKIP_DIRS, JS_TEST_RE, PY_TEST_RE, GO_TEST_RE;
-var init_testmap = __esm(() => {
-  init_resolve();
-  init_scope();
-  SKIP_DIRS = new Set([
-    ".git",
-    "node_modules",
-    "dist",
-    "build",
-    "target",
-    "coverage",
-    ".venv",
-    "venv",
-    "__pycache__",
-    ".tox",
-    ".pytest_cache",
-    ".loki",
-    ".next"
-  ]);
-  JS_TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
-  PY_TEST_RE = /^(test_.+|.+_test)\.py$/;
-  GO_TEST_RE = /_test\.go$/;
-});
-
 // ../../loki-ts/src/util/wall_owned.ts
-import { isAbsolute as isAbsolute4, join as join40, relative as relative4 } from "path";
+import { isAbsolute as isAbsolute4, join as join41, relative as relative4 } from "path";
 function failingLocations(raw2, cwd, repoDir) {
   const out2 = raw2.replace(ANSI2, "").replace(/\r\n?/g, `
 `), files = new Set;
@@ -10551,7 +10733,7 @@ function failingLocations(raw2, cwd, repoDir) {
   }
   if (errors2 === 0 || located !== errors2)
     return null;
-  return [...files].map((f) => relative4(repoDir, isAbsolute4(f) ? f : join40(cwd, f)));
+  return [...files].map((f) => relative4(repoDir, isAbsolute4(f) ? f : join41(cwd, f)));
 }
 function wallOwnedFailure(raw2, cwd, repoDir, wall) {
   const locs = failingLocations(raw2, cwd, repoDir);
@@ -10562,108 +10744,1220 @@ var init_wall_owned = __esm(() => {
   ANSI2 = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
 });
 
-// ../../loki-ts/src/engine10/stages/verify.ts
-import { existsSync as existsSync22, mkdtempSync as mkdtempSync6, realpathSync as realpathSync16, rmSync as rmSync9 } from "fs";
-import { tmpdir as tmpdir8 } from "os";
-import { dirname as dirname12, isAbsolute as isAbsolute5, join as join41, relative as relative5 } from "path";
-function resolveTool(repoDir, bin, fallback, lastResort = fallback) {
-  const inRepo = (p) => {
-    try {
-      const r = relative5(realpathSync16(repoDir), realpathSync16(p));
-      return r !== "" && !r.startsWith("..") && !isAbsolute5(r);
-    } catch {
-      return false;
-    }
-  };
-  const venvEnv = process.env["VIRTUAL_ENV"];
-  const project = [join41(repoDir, ".venv", "bin", bin), join41(repoDir, "venv", "bin", bin), ...venvEnv && inRepo(venvEnv) ? [join41(venvEnv, "bin", bin)] : []].find(existsSync22);
-  return project ? [project, "project"] : [Bun.which(fallback) ? fallback : lastResort, "system"];
+// ../../loki-ts/src/util/atomic.ts
+import {
+  closeSync as closeSync6,
+  fstatSync as fstatSync4,
+  fsyncSync as fsyncSync2,
+  lstatSync as lstatSync7,
+  mkdirSync as mkdirSync11,
+  openSync as openSync6,
+  readSync as readSync5,
+  renameSync as renameSync6,
+  rmSync as rmSync9,
+  statSync as statSync15,
+  unlinkSync as unlinkSync3,
+  writeSync as writeSync3
+} from "fs";
+import { dirname as dirname12 } from "path";
+function durableWriteThenRename(target, body) {
+  mkdirSync11(dirname12(target), { recursive: true });
+  const tmp = `${target}.tmp.${process.pid}.${++_tmpCounter}`;
+  const fd = openSync6(tmp, "w");
+  try {
+    writeSync3(fd, body);
+    fsyncSync2(fd);
+  } finally {
+    closeSync6(fd);
+  }
+  renameSync6(tmp, target);
+  fsyncParentDir(target);
 }
-function runnerCmd(t, repoDir) {
-  switch (t.runner) {
-    case "pytest": {
-      const [cmd, interpreter] = resolveTool(repoDir, "python", "python3", "python");
-      return [cmd, ["-m", "pytest", "-q", t.path], interpreter];
+function fsyncParentDir(target) {
+  let dfd = null;
+  try {
+    dfd = openSync6(dirname12(target), "r");
+    fsyncSync2(dfd);
+  } catch {} finally {
+    if (dfd !== null) {
+      try {
+        closeSync6(dfd);
+      } catch {}
     }
-    case "vitest":
-      return ["npx", ["vitest", "run", t.path]];
-    case "jest":
-      return ["npx", ["jest", t.path]];
-    case "bun":
-      return ["bun", ["test", t.path]];
-    case "node":
-      return ["node", ["--test", `./${t.path}`]];
-    case "npm":
-      return ["npm", ["test", "--silent"]];
-    case "go":
-      return ["go", ["test", "-json", `./${dirname12(t.path)}`]];
-    case "cargo":
-      return ["cargo", ["test"]];
   }
 }
-function commandFor(t, repoDir, api) {
-  const site = siteFor(api, repoDir, t.path);
-  const [cmd, args, interpreter] = runnerCmd(site ? { runner: t.runner, path: site.file } : t, repoDir);
-  return { cwd: site?.cwd ?? repoDir, cmd, args, argv: [cmd, ...args], ...interpreter ? { interpreter } : {}, pkgRoot: site?.root ?? "." };
+function atomicWriteJson(target, data) {
+  durableWriteThenRename(target, `${JSON.stringify(data, null, 2)}
+`);
 }
-function changedFiles(repoDir, baseSha) {
-  const run = (args) => safeGit(repoDir, args).split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const tracked = run(["diff", "--name-only", baseSha]);
-  const untracked = run(["ls-files", "--others", "--exclude-standard"]);
-  return [...new Set([...tracked, ...untracked])].filter((f) => !f.startsWith(".loki/"));
+var _tmpCounter = 0, _appendChains;
+var init_atomic = __esm(() => {
+  _appendChains = new Map;
+});
+
+// ../../loki-ts/src/runner/state.ts
+var TERMINAL_STATUSES;
+var init_state = __esm(() => {
+  init_paths();
+  init_atomic();
+  TERMINAL_STATUSES = new Set([
+    "failed",
+    "max_iterations_reached",
+    "max_retries_exceeded",
+    "exited",
+    "council_approved",
+    "council_force_approved",
+    "completion_promise_fulfilled",
+    "running"
+  ]);
+});
+
+// ../../loki-ts/src/runner/repo_profile.ts
+import { existsSync as existsSync22, readFileSync as readFileSync29, mkdirSync as mkdirSync12, readdirSync as readdirSync12, renameSync as renameSync7, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "fs";
+import { basename as basename15, join as join42, resolve as resolve11, isAbsolute as isAbsolute5 } from "path";
+function loadProfile(repoDir) {
+  try {
+    const p = JSON.parse(readFileSync29(commandProfilePath(repoDir), "utf8"));
+    return p?.version === 1 && Array.isArray(p.commands) && p.baseline ? p : null;
+  } catch {
+    return null;
+  }
 }
-function testConfigChanged(repoDir, baseSha, changed) {
-  const diff = (f) => safeGit(repoDir, ["diff", "-U0", baseSha, "--", f]);
-  return changed.filter((f) => CFG_ALWAYS.test(f) || CFG_SHARED.test(f) && (() => {
-    const d = diff(f);
-    return !d || CFG_LINE.test(d);
-  })());
+function attribute(repoDir, baseSha, failing) {
+  const p = loadProfile(repoDir), none = { preExistingChecks: [], preExistingIds: [], introducedChecks: failing.map((f) => f.name), line: null };
+  if (!p || p.revision !== baseSha || !p.baseline.attributable || p.baseline.failing_ids.length === 0 || failing.length === 0)
+    return none;
+  const base = new Set(p.baseline.failing_ids), pre = failing.filter((f) => f.eligible && f.ids?.length && f.ids.every((i) => base.has(i)));
+  const introduced = failing.filter((f) => !pre.includes(f)).map((f) => f.name);
+  if (pre.length === 0)
+    return { ...none, line: `baseline: ${base.size} known failure(s) before this run; none of the failing checks match them, ${introduced.length} introduced (blocking)` };
+  return {
+    preExistingChecks: pre.map((f) => f.name),
+    preExistingIds: pre.flatMap((f) => f.ids ?? []),
+    introducedChecks: introduced,
+    line: `baseline: ${pre.length} pre-existing failing check(s) (not blocking), ${introduced.length} introduced${introduced.length ? " (blocking)" : ""}`
+  };
 }
-async function runOnce(cmd, args, cwd, signal, opts) {
-  if (!Bun.which(cmd, { PATH: opts.path ?? process.env["PATH"] ?? "" }))
-    return { ok: false, missing: true, cut: false, out: "" };
-  const timeout = AbortSignal.timeout(opts.timeoutMs ?? CHECK_TIMEOUT_MS);
-  const proc = Bun.spawn([cmd, ...args], {
-    cwd,
-    stdin: opts.stdin !== undefined ? Buffer.from(opts.stdin) : "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    signal: AbortSignal.any([signal, timeout]),
-    env: opts.path ? { ...plainTestEnv(), PATH: opts.path } : plainTestEnv()
-  });
-  let tail = "";
-  const rs = [proc.stdout, proc.stderr].map((s) => s.getReader());
-  const pumps = rs.map(async (r) => {
-    const d = new TextDecoder;
-    for (;; ) {
-      const c = await r.read().catch(() => ({ done: true, value: undefined }));
-      if (c.done)
-        return;
-      tail = (tail + d.decode(c.value, { stream: true })).slice(-65536);
-    }
-  });
-  const exitCode = await proc.exited;
-  await Promise.race([Promise.all(pumps), new Promise((r) => setTimeout(r, 300))]);
-  rs.forEach((r) => r.cancel().catch(() => {}));
-  const cut = timeout.aborted || signal.aborted;
-  return { ok: exitCode === 0 && !cut, missing: false, cut, out: cut ? "" : stripAnsi(tail) };
+function attributeFullSuite(repoDir, baseSha, full, blocked, changed) {
+  const bad = full.filter((c) => c.result === "fail"), none = { preExistingChecks: [], preExistingIds: [], introducedChecks: bad.map((c) => c.name), line: null };
+  const norm3 = (s) => s.replace(/\s+--silent\b/, "").trim(), p = loadProfile(repoDir);
+  if (!bad.length || !p || p.revision !== baseSha || !p.baseline.attributable || !p.baseline.failing_ids.length)
+    return none;
+  if (bad.some((c) => norm3(c.cmd) !== norm3(p.baseline.command ?? "")))
+    return { ...none, line: `baseline: ran "${p.baseline.command}", not the full suite command, ids not comparable, full suite failures not excused` };
+  const block = new Set(blocked);
+  return attribute(repoDir, baseSha, bad.map((c) => ({ name: c.name, ...c.ids ? { ids: c.ids } : {}, eligible: (c.ids ?? []).every((i) => !block.has(i) && !changed.some((f) => i.includes(f))) })));
 }
-function firstError(out2) {
-  const goOut = (l2) => {
-    try {
-      const e = JSON.parse(l2);
-      return typeof e.Action === "string" ? e.Action === "output" || e.Action === "build-output" ? e.Output ?? "" : "" : l2;
-    } catch {
-      return l2;
-    }
+var commandProfilePath = (repoDir) => join42(repoDir, ".loki", "state", "repo-profile.json");
+var init_repo_profile = __esm(() => {
+  init_failures();
+  init_check_result();
+  init_safe_git();
+  init_paths();
+  init_state();
+});
+
+// ../../loki-ts/src/project_graph.ts
+import { createHash as createHash10 } from "crypto";
+import {
+  existsSync as existsSync23,
+  readdirSync as readdirSync13,
+  readFileSync as readFileSync30,
+  statSync as statSync16,
+  writeFileSync as writeFileSync15,
+  mkdirSync as mkdirSync13
+} from "fs";
+import { basename as basename16, dirname as dirname13, join as join43, resolve as resolve12 } from "path";
+function readManifest(path) {
+  if (!existsSync23(path)) {
+    return null;
+  }
+  let raw2;
+  try {
+    raw2 = readFileSync30(path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw2);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const obj = parsed;
+  if (obj["schema_version"] !== SUPPORTED_SCHEMA_VERSION) {
+    console.warn(`[loki:project_graph] unsupported schema_version in ${path}: ` + `${String(obj["schema_version"])} (expected ${SUPPORTED_SCHEMA_VERSION})`);
+    return null;
+  }
+  const appId = obj["app_id"];
+  if (typeof appId !== "string" || !APP_ID_REGEX.test(appId)) {
+    console.warn(`[loki:project_graph] invalid app_id in ${path}: ${String(appId)}`);
+    return null;
+  }
+  const members = Array.isArray(obj["members"]) ? obj["members"].filter((m) => typeof m === "string") : [];
+  const sharedMemoryDir = typeof obj["shared_memory_dir"] === "string" ? obj["shared_memory_dir"] : undefined;
+  return {
+    schema_version: SUPPORTED_SCHEMA_VERSION,
+    app_id: appId,
+    members,
+    shared_memory_dir: sharedMemoryDir
   };
-  const lines = out2.slice(-65536).split(`
-`).map((l2) => (l2.startsWith("{") ? goOut(l2) : l2).trim()).filter(Boolean), l = lines.find((x) => /^(FAILED\s|\u25cf\s.*\u203a|not ok\s|_{3,}\s.+\s_{3,}$)/.test(x)) ?? lines.find((x) => /^[\w./-]+\.go:\d+:\d+: \S/.test(x)) ?? lines.find((x) => /fail|error/i.test(x) && !/^(=|\u2713|ok\b|PASS)/.test(x)) ?? "";
-  return l.replace(/\d{4}-\d\d-\d\dT[\d:.]+Z?/g, "").replace(/(^|\s)\/(?:[\w.@-]+\/)*[\w.@-]+/g, "$1<path>").replace(/:\d+(?::\d+)?/g, "").replace(/\[?\d+(?:\.\d+)?m?s\]?/g, "").replace(/\s+/g, " ").slice(0, 160);
 }
-async function runCheck(ctx, name, cmd, args, signal, checks, opts = {}) {
-  const started = Date.now();
+function resolveMembers(rootDir, declared, selfBasename) {
+  const out2 = [];
+  const seen = new Set;
+  let children;
+  try {
+    children = readdirSync13(rootDir);
+  } catch {
+    children = [];
+  }
+  const matchPattern = (pattern, name) => {
+    if (!pattern.includes("*") && !pattern.includes("?")) {
+      return pattern === name;
+    }
+    const re = new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+    return re.test(name);
+  };
+  for (const name of declared) {
+    for (const child of children) {
+      if (!matchPattern(name, child))
+        continue;
+      const full = join43(rootDir, child);
+      if (seen.has(full))
+        continue;
+      let st;
+      try {
+        st = statSync16(full);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory())
+        continue;
+      seen.add(full);
+      out2.push(full);
+    }
+  }
+  if (declared.length === 0) {
+    for (const child of children) {
+      const full = join43(rootDir, child);
+      if (seen.has(full))
+        continue;
+      let st;
+      try {
+        st = statSync16(full);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory())
+        continue;
+      if (!existsSync23(join43(full, ".loki", "app.json")))
+        continue;
+      seen.add(full);
+      out2.push(full);
+    }
+  }
+  return out2;
+}
+function cacheKey(manifestPaths) {
+  const parts = [];
+  for (const p of manifestPaths.sort()) {
+    let mtime = 0;
+    try {
+      mtime = statSync16(p).mtimeMs;
+    } catch {}
+    parts.push(`${p}:${mtime}`);
+  }
+  return createHash10("sha256").update(parts.join("|")).digest("hex");
+}
+function writeCache(targetDir, key, result) {
+  try {
+    const cacheDir = join43(targetDir, ".loki", "state");
+    mkdirSync13(cacheDir, { recursive: true });
+    const cachePath = join43(cacheDir, "project-graph.json");
+    writeFileSync15(cachePath, JSON.stringify({ key, result }, null, 2), "utf8");
+  } catch {}
+}
+function discoverProjectGraph(targetDir) {
+  const absTarget = resolve12(targetDir);
+  const targetManifest = join43(absTarget, ".loki", "app.json");
+  const parentDir = dirname13(absTarget);
+  const parentManifest = join43(parentDir, ".loki", "app.json");
+  const examined = [];
+  let chosenManifest = null;
+  let chosenRoot = "";
+  if (existsSync23(parentManifest) && parentDir !== absTarget) {
+    examined.push(parentManifest);
+    chosenManifest = readManifest(parentManifest);
+    chosenRoot = parentDir;
+  }
+  if (!chosenManifest && existsSync23(targetManifest)) {
+    examined.push(targetManifest);
+    chosenManifest = readManifest(targetManifest);
+    chosenRoot = absTarget;
+  }
+  if (!chosenManifest)
+    return null;
+  const declared = chosenManifest.members ?? [];
+  const members = resolveMembers(chosenRoot, declared, basename16(absTarget));
+  const filtered = [];
+  for (const m of members) {
+    const sibManifestPath = join43(m, ".loki", "app.json");
+    if (existsSync23(sibManifestPath)) {
+      examined.push(sibManifestPath);
+      const sibManifest = readManifest(sibManifestPath);
+      if (sibManifest && sibManifest.app_id !== chosenManifest.app_id) {
+        continue;
+      }
+    }
+    filtered.push(m);
+  }
+  const result = {
+    appId: chosenManifest.app_id,
+    root: chosenRoot,
+    members: filtered,
+    sharedMemoryDir: chosenManifest.shared_memory_dir
+  };
+  writeCache(absTarget, cacheKey(examined), result);
+  return result;
+}
+var APP_ID_REGEX, SUPPORTED_SCHEMA_VERSION = 1;
+var init_project_graph = __esm(() => {
+  APP_ID_REGEX = /^[a-z0-9-]{3,40}$/;
+});
+
+// ../../loki-ts/src/util/shell.ts
+async function readStreamCapped(stream, maxBytes = MAX_STDOUT_BYTES) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let out2 = "";
+  let total = 0;
+  try {
+    while (total < maxBytes) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!value)
+        continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        const keep = value.byteLength - (total - maxBytes);
+        out2 += decoder.decode(value.subarray(0, keep), { stream: true });
+        break;
+      }
+      out2 += decoder.decode(value, { stream: true });
+    }
+    out2 += decoder.decode();
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
+    reader.releaseLock();
+  }
+  return out2;
+}
+async function run(argv, opts = {}) {
+  const proc = Bun.spawn({
+    cmd: [...argv],
+    stdout: "pipe",
+    stderr: "pipe",
+    env: opts.env ? { ...process.env, ...opts.env } : process.env,
+    cwd: opts.cwd
+  });
+  let timer;
+  let killTimer;
+  if (opts.timeoutMs && opts.timeoutMs > 0) {
+    timer = setTimeout(() => {
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+      killTimer = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 2000);
+    }, opts.timeoutMs);
+  }
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      readStreamCapped(proc.stdout),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    return { stdout, stderr, exitCode };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (killTimer)
+      clearTimeout(killTimer);
+  }
+}
+var MAX_STDOUT_BYTES;
+var init_shell = __esm(() => {
+  MAX_STDOUT_BYTES = 16 * 1024 * 1024;
+});
+
+// ../../loki-ts/src/e10ext/budget_cap.ts
+var DEFAULT_MAX_COST_USD;
+var init_budget_cap = __esm(() => {
+  init_budget();
+  DEFAULT_MAX_COST_USD = loadDefaultMaxCostUsd();
+});
+
+// ../../loki-ts/src/runner/retry_class.ts
+var init_retry_class = () => {};
+
+// ../../loki-ts/src/features/speed/unit_mode.ts
+import { closeSync as closeSync7, constants as constants2, fstatSync as fstatSync5, lstatSync as lstatSync8, openSync as openSync7, readSync as readSync6, realpathSync as realpathSync16 } from "fs";
+function readBounded(path) {
+  const l = lstatSync8(path);
+  if (l.isSymbolicLink() || !l.isFile() || l.size > MAX_SPEC_BYTES)
+    return null;
+  const fd = openSync7(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  try {
+    const st = fstatSync5(fd);
+    if (!st.isFile() || st.size > MAX_SPEC_BYTES)
+      return null;
+    const buf = Buffer.alloc(st.size + 1);
+    let n2 = 0;
+    for (;; ) {
+      const r = readSync6(fd, buf, n2, buf.length - n2, null);
+      if (r <= 0)
+        break;
+      n2 += r;
+      if (n2 >= buf.length)
+        return null;
+    }
+    return buf.subarray(0, n2).toString("utf8");
+  } finally {
+    closeSync7(fd);
+  }
+}
+function parseText(txt) {
+  try {
+    const j = JSON.parse(txt), ws = strs(j.writeSet), pack = strs(j.pack), tb = j.tokenBudget;
+    if (typeof j.id !== "string" || !j.id || !ws || ws.length === 0 || !pack || typeof tb !== "number" || !Number.isFinite(tb) || !(tb > 0) || tb > MAX_TOKEN_BUDGET)
+      return null;
+    return { id: j.id, writeSet: ws, pack, tokenBudget: tb };
+  } catch {
+    return null;
+  }
+}
+function parseSpec(path) {
+  try {
+    const txt = readBounded(path);
+    return txt === null ? null : parseText(txt);
+  } catch {
+    return null;
+  }
+}
+function unitSpec(env = process.env) {
+  const path = env["LOKI_UNIT_SPEC"], frozen = env["LOKI_UNIT_SPEC_FROZEN"];
+  if (env["LOKI_SPEED"] === "0" || !path)
+    return null;
+  if (frozen !== undefined)
+    return frozen.length <= MAX_SPEC_BYTES ? parseText(frozen) : null;
+  if (!memo.has(path))
+    memo.set(path, parseSpec(path));
+  return memo.get(path) ?? null;
+}
+function unitFlags(staged, env = process.env, pre = {}) {
+  const s = unitSpec(env);
+  return s ? staged.filter(({ f }) => !inWriteSet(s, f) && !Object.hasOwn(pre, f)).map(({ f }) => f) : null;
+}
+var MAX_SPEC_BYTES, MAX_TOKEN_BUDGET = 1e9, norm3 = (p) => p.replace(/^\.\//, ""), CTRL, strs = (v) => Array.isArray(v) && v.every((x) => typeof x === "string" && !CTRL.test(x)) ? v.map(norm3) : null, memo, inWriteSet = (spec, f) => spec.writeSet.some((w) => w.endsWith("/") ? f.startsWith(w) : f === w);
+var init_unit_mode = __esm(() => {
+  MAX_SPEC_BYTES = 1024 * 1024;
+  CTRL = /[\x00-\x1f\x7f]/;
+  memo = new Map;
+});
+
+// ../../loki-ts/src/e10ext/repomemory.ts
+var init_repomemory = __esm(() => {
+  init_cache();
+});
+
+// ../../loki-ts/src/e10ext/context.ts
+var FINISH_LINE = "Finish with exactly one line: LOKI_DONE, or LOKI_ALREADY_DONE: <file:line evidence>, or LOKI_SPEC_CONFLICT: <reason>.", FIXED_RULES;
+var init_context = __esm(() => {
+  init_cache();
+  init_sizing();
+  init_unit_mode();
+  init_repomemory();
+  init_repo_profile();
+  FIXED_RULES = [
+    "You are the Loki 10 implement stage, doing the complete task described below in this repository. Do whatever a senior engineer would do to finish it correctly: read, change and test as needed across any files the task requires.",
+    "Rules:",
+    "- The Wall tests are read-only: do not edit or delete them. Existing test files are append-only: you may add new test functions, but never edit or delete an existing one.",
+    "- Exception: when the task text itself states the new expected value of an existing assertion, change only that literal in that assertion; never remove, skip or loosen an assertion, and never edit one the task text does not name.",
+    "- Run any tests you need, including the package's full suite (the Project Model commands below say how). The impacted tests named below are a starting hint, not a limit.",
+    "- Never leave a long-lived server running.",
+    "- Never kill processes.",
+    "- Write no documentation unless the task explicitly asks for it.",
+    "- Do not commit or push.",
+    "- If you add a new third-party registry dependency, list it in .loki/supply-declared.json as a JSON array of {ecosystem,name,version_spec,registry}, leaving out workspace, path, git and local packages.",
+    FINISH_LINE
+  ].join(`
+`);
+});
+
+// ../../loki-ts/src/util/steer.ts
+var STEER_MAX_BYTES, STEER_STAGES;
+var init_steer = __esm(() => {
+  init_context();
+  STEER_MAX_BYTES = 1024 * 1024;
+  STEER_STAGES = new Set(["plan", "implement"]);
+});
+
+// ../../loki-ts/src/util/pr_lessons.ts
+import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync31 } from "fs";
+import { dirname as dirname14, join as join44 } from "path";
+function loadLessons(repoDir) {
+  const p = lessonsPath(repoDir);
+  if (!existsSync24(p))
+    return [];
+  try {
+    const j = JSON.parse(readFileSync31(p, "utf-8"));
+    return Array.isArray(j.lessons) ? j.lessons : [];
+  } catch {
+    return [];
+  }
+}
+function save(repoDir, lessons) {
+  const p = lessonsPath(repoDir);
+  mkdirSync14(dirname14(p), { recursive: true });
+  atomicWriteJson(p, { version: 2, lessons });
+}
+function recordRunVerdict(repoDir, runId, verdict) {
+  const lessons = loadLessons(repoDir);
+  let dirty = false;
+  for (const l of lessons)
+    for (const u of l.uses)
+      if (u.run_id === runId && u.verdict === null) {
+        u.verdict = verdict;
+        dirty = true;
+      }
+  if (dirty)
+    save(repoDir, lessons);
+}
+var lessonsPath = (repoDir) => join44(repoDir, ".loki", "memory", "semantic", "pr-lessons.json");
+var init_pr_lessons = __esm(() => {
+  init_atomic();
+});
+
+// ../../loki-ts/src/runner/model_downgrades.ts
+var init_model_downgrades = __esm(() => {
+  init_sizing();
+  init_decision();
+});
+
+// ../../loki-ts/src/providers/mcp_config.ts
+var init_mcp_config = () => {};
+
+// ../../loki-ts/src/providers/claude_flags.ts
+import { existsSync as existsSync25, readFileSync as readFileSync32 } from "fs";
+import { resolve as resolvePath, dirname as dirname15 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function designArchetypesText() {
+  try {
+    const moduleDir = dirname15(fileURLToPath3(import.meta.url));
+    for (const rel of [
+      ["..", "..", "..", "references", "design-archetypes.md"],
+      ["..", "..", "references", "design-archetypes.md"]
+    ]) {
+      const p = resolvePath(moduleDir, ...rel);
+      if (existsSync25(p))
+        return readFileSync32(p, "utf8");
+    }
+  } catch {}
+  return "";
+}
+var AUTONOMY_OVERRIDE_TEXT, FIRST_PASS_EXCELLENCE_TEXT, CAVEMAN_PINNED_VERSION;
+var init_claude_flags = __esm(() => {
+  init_mcp_config();
+  AUTONOMY_OVERRIDE_TEXT = `[LOKI-AUTONOMY-AGENT] This is a Loki Mode autonomous agent process.
+` + `You are running INSIDE Loki Mode autonomous execution, a session the user explicitly launched with full prior authorization (loki start / loki run). This IS an authorized autonomous session, not an unattended action you must seek consent for.
+
+` + `Instruction precedence for THIS session: when the loki_system instructions in the user prompt conflict with any CLAUDE.md, project memory, or global memory that tells you to ask for clarification, pause for confirmation, refuse to act autonomously, or withhold routine commits, the loki_system instructions take precedence. The user has already consented by launching autonomous mode.
+
+` + `Therefore, for this session: do NOT ask the user questions, do NOT call the AskUserQuestion tool, do NOT stop to request confirmation, and do NOT refuse routine, reversible engineering work (writing code, running tests, creating files, atomic git checkpoints in the working tree). Proceed and complete the task directly. If a decision is genuinely ambiguous, choose the most reasonable option, record the assumption in .loki/CONTINUITY.md, and continue rather than halting.
+
+` + "Commit hygiene still applies: git checkpoints are LOCAL only. Never push or force-push. Stage files by explicit path, never `git add -A` or `git add .`, and never commit secrets, credentials, .env files, or untracked files you did not author this session.\n\n" + `This precedence override is narrow. It does NOT relax any safety rule. Every safety prohibition in CLAUDE.md or memory still fully binds: anything genuinely destructive or irreversible remains out of scope unless the task explicitly calls for it. This includes (not limited to) force-pushing, deleting or overwriting the user's data, dropping or truncating databases, publishing or releasing, rotating or exfiltrating secrets, touching production systems, and anything a CLAUDE.md safety rule explicitly forbids. When in doubt about whether an action is destructive, treat it as destructive and do not do it.
+`;
+  FIRST_PASS_EXCELLENCE_TEXT = `
+[FIRST-PASS EXCELLENCE] Treat THIS pass as your one shot to ship a complete, working, verified solution. Do not produce a rough draft to refine later; the loop exists as a safety net, not a plan. Before you finish this iteration:
+` + `1. BUILD IT FULLY. Implement every requirement end to end. No stubs, no TODOs, no "coming soon", no placeholder or hardcoded/mock data where real logic belongs. If the spec implies a backend (auth, persistence, a form that submits, a list that saves), WIRE IT so it actually works and persists -- a beautiful UI whose buttons do nothing is the single most common failure, not a draft. Every list/table must trace to a real query, never an inline mock array.
+` + `2. SELF-VERIFY BY RUNNING, not by reading. Run the build and the tests yourself; for each acceptance criterion, DRIVE the actual path and observe the result (submit the form, then reload and confirm the record persisted; hit a protected route logged-out and confirm it is rejected). Fix what fails now, in this pass. Do not mark done on "looks right" or a self-claim -- observed behavior is the only proof.
+` + `3. LOCK THE ARCHITECTURE on this pass so later edits are small and additive. Decide the data model, routes, and component structure up front and build to them; never rewrite whole files later to patch a small thing (that is the doom loop that breaks working features).
+` + `4. DESIGN: commit to ONE named aesthetic direction up front (editorial, brutalist, luxury, retro-futuristic, soft/pastel, industrial, etc. -- chosen from the product domain) and hold it on every surface. Use real content (never lorem). AVOID the AI-slop tells that instantly read as machine-generated: NO indigo/blue-to-purple gradient (the #1 tell), NO Inter/Roboto/system-font headlines (pick a real display+body pairing), NO three-equal-rounded-cards-in-a-row skeleton, NO flat 1px gray card borders or colored left-border strips, NO untouched shadcn defaults, NO reflexive dark mode. Cap the palette at ~3 hues (60/30/10), tinted not pure #fff/#000, separate sections by whitespace then a slight background shift before any border. Aim for Linear/Stripe/Duolingo-tier taste: "this does not look AI-generated".
+` + `5. SATISFY THE GATES THAT WILL JUDGE THIS PASS. Your work is checked by deterministic gates before it can be accepted, and in measured runs EVERY extra iteration was caused by one of these rejecting the work -- never by the model failing to finish. Clear them now, in this pass:
+` + `   - STATIC ANALYSIS: no syntax errors, no unused/undefined symbols, no lint errors in files you touched.
+` + `   - TEST SUITE: the existing tests must still pass. Run them; do not assume.
+` + `   - MUTATION/MOCK INTEGRITY: tests must assert real behaviour. No tautological assertions (expect(true).toBe(true)), no test that passes whether or not the code works, no mocking the very unit under test, no inline mock data standing in for a real query.
+` + `   - CODE REVIEW: no scope creep beyond the stated task, no dead or commented-out code, no leftover debug output, and follow the conventions already in the surrounding files.
+` + `Deliver the finished, self-verified, genuinely-designed result in THIS pass. Additional iterations should be the exception, not the plan.
+` + designArchetypesText();
+  CAVEMAN_PINNED_VERSION = process.env["LOKI_CAVEMAN_VERSION"] || "1.9.0";
+});
+
+// ../../loki-ts/src/runner/sdk_stream_parser.ts
+var init_sdk_stream_parser = __esm(() => {
+  init_cost();
+  init_budget();
+});
+
+// ../../loki-ts/src/runner/trim.ts
+var init_trim = () => {};
+
+// ../../loki-ts/src/util/update_check.ts
+var CACHE_TTL_MS;
+var init_update_check = __esm(() => {
+  init_paths();
+  CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+});
+
+// ../../loki-ts/src/runner/router/advisor_probe.ts
+var init_advisor_probe = __esm(() => {
+  init_update_check();
+});
+
+// ../../loki-ts/src/runner/provider_opencode.ts
+var init_provider_opencode = __esm(() => {
+  init_shell();
+  init_providers();
+});
+
+// ../../loki-ts/src/runner/providers.ts
+var _installedVersionCache;
+var init_providers = __esm(() => {
+  init_shell();
+  init_paths();
+  init_claude_flags();
+  init_mcp_config();
+  init_lean_prefix();
+  init_sdk_stream_parser();
+  init_trim();
+  init_advisor_probe();
+  init_claude_model();
+  init_model_routes();
+  init_provider_opencode();
+  _installedVersionCache = new Map;
+});
+
+// ../../loki-ts/src/runner/router/route_record.ts
+import { existsSync as existsSync26, lstatSync as lstatSync9, mkdirSync as mkdirSync15, readFileSync as readFileSync33, writeFileSync as writeFileSync16 } from "fs";
+import { join as join45 } from "path";
+function loadRouteRecord(runDir) {
+  try {
+    const p = join45(runDir, ROUTE_RECORD_FILE);
+    if (!existsSync26(p) || !lstatSync9(p).isFile())
+      return;
+    const v = JSON.parse(readFileSync33(p, "utf8"));
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
+  } catch {
+    return;
+  }
+}
+var ROUTE_RECORD_FILE = "route.json";
+var init_route_record = () => {};
+
+// ../../loki-ts/src/runner/router/history_store.ts
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync34, renameSync as renameSync8, rmSync as rmSync11, writeFileSync as writeFileSync17 } from "fs";
+import { resolve as resolve13 } from "path";
+function validRun(v) {
+  if (typeof v !== "object" || v === null)
+    return false;
+  const r = v;
+  return typeof r["shape"] === "string" && typeof r["executor"] === "string" && EXECUTORS.includes(r["executor"]) && typeof r["verdict"] === "string" && VERDICTS.includes(r["verdict"]) && (r["owner"] === null || typeof r["owner"] === "string" && OWNERS.includes(r["owner"])) && typeof r["escalated"] === "boolean" && typeof r["usd"] === "number" && Number.isFinite(r["usd"]) && typeof r["wallS"] === "number" && Number.isFinite(r["wallS"]);
+}
+function historyPath(key, cacheRoot) {
+  return resolve13(repoCacheDir(key, cacheRoot), HISTORY_FILE);
+}
+function readRunHistory(key, cacheRoot) {
+  const path = historyPath(key, cacheRoot);
+  if (!existsSync27(path))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync34(path, "utf8"));
+    const runs2 = parsed?.runs;
+    return Array.isArray(runs2) ? runs2.filter(validRun) : [];
+  } catch {
+    return [];
+  }
+}
+function appendRunOutcome(key, outcome, cacheRoot) {
+  try {
+    const runs2 = [...readRunHistory(key, cacheRoot), outcome].slice(-HISTORY_CAP);
+    mkdirSync16(repoCacheDir(key, cacheRoot), { recursive: true });
+    const target = historyPath(key, cacheRoot);
+    const tmp = `${target}.${process.pid}.tmp`;
+    try {
+      writeFileSync17(tmp, JSON.stringify({ runs: runs2 }));
+      renameSync8(tmp, target);
+    } catch (e) {
+      rmSync11(tmp, { force: true, recursive: false });
+      throw e;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HISTORY_FILE = "router_history.json", HISTORY_CAP = 200, WALL_KIND = "total-v1", EXECUTORS, VERDICTS, OWNERS;
+var init_history_store = __esm(() => {
+  init_cache();
+  EXECUTORS = ["haiku", "sonnet"];
+  VERDICTS = ["pass", "fail", "error", "not_proven"];
+  OWNERS = ["code", "harness", "env", "provider"];
+});
+
+// ../../loki-ts/src/runner/router/history.ts
+import { dirname as dirname16, join as join46, resolve as resolve14 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function shapeKey(model) {
+  if (!model || model.status !== "ok")
+    return null;
+  const runners = new Set(model.packages.map((p) => (p.runner ?? "").trim().toLowerCase() || "none"));
+  return `${model.workspaceKind}:${[...runners].sort().join("+")}`;
+}
+function shapeKeyForRepo(repoDir) {
+  try {
+    const dirs = shallowDirs(repoDir);
+    const committed = loadCommitted(repoDir);
+    if (committed)
+      return shapeKey({ ...committed.model, key: computeKey(repoDir, committed.model.fingerprintFiles, dirs, committed.hash) });
+    const cached = loadCached(repoDir);
+    if (!cached || computeKey(repoDir, cached.fingerprintFiles, dirs) !== cached.key)
+      return null;
+    return shapeKey(cached);
+  } catch {
+    return null;
+  }
+}
+var SHAPE_DEFAULTS_FILE;
+var init_history = __esm(() => {
+  init_schema();
+  init_history_store();
+  init_discover2();
+  init_gather();
+  init_history_store();
+  SHAPE_DEFAULTS_FILE = resolve14(dirname16(fileURLToPath4(import.meta.url)), "..", "..", "..", "data", "router-shape-defaults.json");
+});
+
+// ../../loki-ts/src/runner/router/plan_route.ts
+var init_plan_route = __esm(() => {
+  init_run_cap();
+  init_providers();
+  init_decision();
+  init_advisor_probe();
+  init_route_record();
+  init_history();
+});
+
+// ../../loki-ts/src/util/intent_card.ts
+var INTENT_HEADER = "What I think you want:", CARD_MIN_LINES = 3, CARD_MAX_LINES = 5, INTENT_CARD_INSTRUCTION;
+var init_intent_card = __esm(() => {
+  INTENT_CARD_INSTRUCTION = `After the plan lines, append an intent card of ${CARD_MIN_LINES} to ${CARD_MAX_LINES} lines: a first line starting "${INTENT_HEADER}" with one sentence on what you think the user wants, then ${CARD_MIN_LINES - 1} to ${CARD_MAX_LINES - 1} lines each starting "Acceptance:" naming one check you will hold yourself to. You may add one optional line starting "Out of scope:" naming what you will NOT do; it counts toward the ${CARD_MAX_LINES} lines.`;
+});
+
+// ../../loki-ts/src/engine10/repomap.ts
+var init_repomap = __esm(() => {
+  init_safe_git();
+});
+
+// ../../loki-ts/src/util/reviewer_brief.ts
+var init_reviewer_brief = __esm(() => {
+  init_repomap();
+  init_safe_git();
+});
+
+// ../../loki-ts/src/engine10/stages/plan.ts
+var init_plan = __esm(() => {
+  init_session();
+  init_sizing();
+  init_lean_prefix();
+  init_types();
+  init_run_cap();
+  init_wall();
+  init_model_downgrades();
+  init_plan_route();
+  init_intent_card();
+  init_mutation_proof();
+  init_reviewer_brief();
+});
+
+// ../../loki-ts/src/runner/session_resume.ts
+var init_session_resume = __esm(() => {
+  init_session();
+});
+
+// ../../loki-ts/src/util/conflict_resume.ts
+var CONFLICT_CORRECTION, EMPTY_DONE_CORRECTION;
+var init_conflict_resume = __esm(() => {
+  init_session_resume();
+  init_context();
+  CONFLICT_CORRECTION = "Loki imposes no file or test limits on you. If your conflict is only about Loki's own rules, finish the task. If the task itself conflicts, restate the conflict. " + FINISH_LINE;
+  EMPTY_DONE_CORRECTION = "Your session finished with LOKI_DONE but the working tree has no change against the base. Make the change the task asks for, or if the task is already satisfied finish with LOKI_ALREADY_DONE: <file:line evidence>, or if the task itself conflicts finish with LOKI_SPEC_CONFLICT: <reason>. " + FINISH_LINE;
+});
+
+// ../../loki-ts/src/runner/router/implement_route.ts
+var init_implement_route = __esm(() => {
+  init_model_rank();
+  init_unit_model();
+});
+
+// ../../loki-ts/src/engine10/stages/implement.ts
+var init_implement = __esm(() => {
+  init_lean_prefix();
+  init_pr_lessons();
+  init_context();
+  init_model_downgrades();
+  init_sizing();
+  init_plan();
+  init_verify();
+  init_resolve();
+  init_session();
+  init_conflict_resume();
+  init_session_resume();
+  init_implement_route();
+  init_unit_model();
+  init_types();
+  init_spec_file();
+});
+
+// ../../loki-ts/src/engine10/machine.ts
+var init_machine = __esm(() => {
+  init_hooks();
+  init_retry_class();
+  init_registry();
+  init_run_cap();
+  init_context();
+  init_steer();
+  init_implement();
+  init_unit_model();
+  init_types();
+});
+
+// ../../loki-ts/src/runner/provider_failover.ts
+var DEFAULT_ORDER, ALLOWED;
+var init_provider_failover = __esm(() => {
+  DEFAULT_ORDER = ["claude", "cline", "codex", "aider", "opencode"];
+  ALLOWED = new Set(DEFAULT_ORDER);
+});
+
+// ../../loki-ts/src/engine10/worker.ts
+function assertWorkerEnv(env = process.env) {
+  if (env.LOKI_ALLOW_AGENT_GITHUB_TOKEN === "1")
+    return;
+  for (const v of GITHUB_TOKEN_VARS) {
+    const val = env[v] ?? "";
+    if (val !== "" && !val.startsWith(SENTINEL_PREFIX)) {
+      throw new Error(`engine10 worker: ${v} holds a real token; the worker must run with withheld credentials`);
+    }
+  }
+}
+var init_worker = __esm(() => {
+  init_credential_env();
+  init_cost();
+  init_budget_cap();
+  init_run_cap();
+  init_resolve();
+  init_budget_cap();
+  init_machine();
+  init_provider_failover();
+  init_session();
+  init_testmap();
+  init_types();
+  init_safe_git();
+});
+
+// ../../loki-ts/src/project_model/package_suite.ts
+import { join as join47 } from "path";
+async function runPackageSuites(repoDir, signal, opts, checks, notProven) {
+  const api = loadProjectApi(repoDir);
+  if (!isMultiRoot(api))
+    return false;
+  const withTests = api.packages().filter((p) => p.commands.test);
+  if (withTests.length === 0)
+    return false;
+  for (const pkg of withTests) {
+    const tc = pkg.commands.test, name = `full suite: ${pkg.name}`, cmd = `(cd ${tc.cwd} && ${tc.cmd})`;
+    const started = Date.now();
+    const r = await run(["bash", "-c", tc.cmd], { cwd: join47(repoDir, tc.cwd), timeoutMs: opts.timeoutMs, ...opts.path ? { env: { PATH: opts.path } } : {} });
+    const duration_s = (Date.now() - started) / 1000;
+    if (signal.aborted) {
+      checks.push({ name, cmd, result: "not_run", duration_s });
+      notProven.add(`not run: ${name} (aborted)`);
+      continue;
+    }
+    const out2 = `${r.stdout}
+${r.stderr}`;
+    const lr = r.exitCode === 0 || !opts.baseSha ? undefined : await harnessLoadReason({ repoDir, baseSha: opts.baseSha, out: out2, cmd: "bash", args: ["-c", tc.cmd], signal, cwd: join47(repoDir, tc.cwd), ...opts.path ? { env: { PATH: opts.path } } : {} });
+    if (lr) {
+      checks.push({ name, cmd, result: "not_run", duration_s });
+      notProven.add(`${lr} (${name}; harness-owned)`);
+      continue;
+    }
+    const cls = classifyCheck({ kind: "test", ok: r.exitCode === 0, out: out2, ...goRunner(tc.cmd) });
+    checks.push({ name, cmd, result: cls.result, duration_s, ...cls.result === "fail" ? { ids: failIds(out2) } : {} });
+    if (cls.result === "not_run")
+      notProven.add(`not run: ${name} (${cls.reason ?? NO_TESTS_REASON})`);
+  }
+  for (const pkg of api.packages().filter((p) => !p.commands.test))
+    notProven.add(`full suite: package ${pkg.name} defines no test command`);
+  return true;
+}
+var init_package_suite = __esm(() => {
+  init_load_owner();
+  init_check_result();
+  init_shell();
+  init_failures();
+  init_resolve();
+});
+
+// ../../loki-ts/src/engine10/stages/deep.ts
+var exports_deep = {};
+__export(exports_deep, {
+  stage: () => stage,
+  runFullSuite: () => runFullSuite,
+  runDeep: () => runDeep,
+  deepStage: () => deepStage,
+  DEFAULT_SECRET_SCAN_SH: () => DEFAULT_SECRET_SCAN_SH,
+  DEFAULT_PUSH_SH: () => DEFAULT_PUSH_SH
+});
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18 } from "fs";
+import { join as join48 } from "path";
+async function runFullSuite(ctx, signal, opts, checks, notProven) {
+  if (await runPackageSuites(ctx.repoDir, signal, { path: opts.path, timeoutMs: opts.fullSuiteTimeoutMs ?? FULL_SUITE_TIMEOUT_MS, baseSha: ctx.baseSha }, checks, notProven))
+    return;
+  const map = await ctx.tests.detect(ctx.repoDir);
+  if (map.runners.length === 0) {
+    notProven.add("full suite (no test runner detected)");
+    return;
+  }
+  for (const runner of map.runners) {
+    const spec = FULL_SUITE_CMD[runner];
+    const name = `full suite: ${runner}`;
+    if (!Bun.which(spec.cmd, opts.path ? { PATH: opts.path } : undefined)) {
+      checks.push({ name, cmd: [spec.cmd, ...spec.args].join(" "), result: "not_run", duration_s: 0 });
+      notProven.add(`not run: ${name}`);
+      continue;
+    }
+    const started = Date.now();
+    const r = await run([spec.cmd, ...spec.args], {
+      cwd: ctx.repoDir,
+      timeoutMs: opts.fullSuiteTimeoutMs ?? FULL_SUITE_TIMEOUT_MS,
+      ...opts.path ? { env: { PATH: opts.path } } : {}
+    });
+    const durationS = (Date.now() - started) / 1000;
+    if (signal.aborted) {
+      checks.push({ name, cmd: [spec.cmd, ...spec.args].join(" "), result: "not_run", duration_s: durationS });
+      notProven.add(`not run: ${name} (aborted)`);
+      continue;
+    }
+    const out2 = `${r.stdout}
+${r.stderr}`, lr = r.exitCode === 0 ? undefined : await harnessLoadReason({ repoDir: ctx.repoDir, baseSha: ctx.baseSha, out: out2, cmd: spec.cmd, args: spec.args, signal, ...opts.path ? { env: { PATH: opts.path } } : {} });
+    if (lr) {
+      checks.push({ name, cmd: [spec.cmd, ...spec.args].join(" "), result: "not_run", duration_s: durationS });
+      notProven.add(`${lr} (${name}; harness-owned)`);
+      continue;
+    }
+    const cls = classifyCheck({ kind: "test", ok: r.exitCode === 0, out: out2, ...goRunner(spec.cmd, spec.args) });
+    checks.push({ name, cmd: [spec.cmd, ...spec.args].join(" "), result: cls.result, duration_s: durationS, ...cls.result === "fail" ? { ids: failIds(out2) } : {} });
+    if (cls.result === "not_run")
+      notProven.add(`not run: ${name} (${cls.reason ?? NO_TESTS_REASON})`);
+  }
+}
+function runAppBoot(ctx, opts, checks, notProven) {
+  const discover = opts.discoverGraph ?? discoverProjectGraph;
+  let graph = null;
+  try {
+    graph = discover(ctx.repoDir);
+  } catch {
+    graph = null;
+  }
+  checks.push({
+    name: "app boot",
+    cmd: "project_graph.ts discoverProjectGraph",
+    result: "not_run",
+    duration_s: 0
+  });
+  notProven.add(graph ? `app boot not run (app graph discovered, ${graph.members.length} member(s))` : "app boot not run (no app graph discovered)");
+}
+async function runCouncilCheck(ctx, changed, baseSha, signal, opts, checks, notProven) {
+  const codeFiles = changed.filter((f) => !f.endsWith(".md"));
+  if (codeFiles.length === 0) {
+    notProven.add("council (no non-doc changes to review)");
+    return;
+  }
+  if (!opts.council) {
+    notProven.add("council (not wired: see the contract-gap note in stages/deep.ts)");
+    return;
+  }
+  const diffResult = await safeGitRun(ctx.repoDir, ["diff", "--no-color", baseSha, "HEAD", "--", ...codeFiles], { timeoutMs: 20000 });
+  const diff = diffResult.exitCode === 0 ? diffResult.stdout : "";
+  const maxBytes = opts.maxCouncilDiffBytes ?? MAX_COUNCIL_DIFF_BYTES;
+  if (Buffer.byteLength(diff, "utf8") > maxBytes) {
+    notProven.add("council (context oversized, refused)");
+    return;
+  }
+  const started = Date.now();
+  try {
+    const outcome = await opts.council.run({ runId: ctx.runId, diff, files: codeFiles }, signal);
+    checks.push({ name: "council", cmd: "dispatchClaudeAgents", result: "pass", duration_s: (Date.now() - started) / 1000 });
+  } catch (err) {
+    notProven.add(`council (refused: ${err.message})`);
+  }
+}
+async function runSecretScan(ctx, changed, opts, checks, notProven) {
+  const scriptPath = opts.secretScanShPath ?? DEFAULT_SECRET_SCAN_SH;
+  const name = "security scan";
+  if (!existsSync28(scriptPath)) {
+    checks.push({ name, cmd: "secret-scan.sh", result: "not_run", duration_s: 0 });
+    notProven.add(`not run: ${name} (secret-scan.sh not found)`);
+    return;
+  }
+  if (changed.length === 0) {
+    checks.push({ name, cmd: "secret-scan.sh", result: "pass", duration_s: 0 });
+    return;
+  }
+  const inline = 'script="$1"; shift; . "$script" || exit 3; hit=0; for f in "$@"; do if _commit_scan_secret_file "$f" || _commit_path_looks_secret "$f"; then printf "%s\\n" "$f"; hit=1; fi; done; exit "$hit"';
+  const started = Date.now();
+  const r = await run(["bash", "-c", inline, "_", scriptPath, ...changed.map((f) => join48(ctx.repoDir, f))], { cwd: ctx.repoDir, timeoutMs: 30000 });
+  const durationS = (Date.now() - started) / 1000;
+  if (r.exitCode === 3) {
+    checks.push({ name, cmd: "secret-scan.sh", result: "not_run", duration_s: durationS });
+    notProven.add(`not run: ${name} (secret-scan.sh failed to load)`);
+    return;
+  }
+  const hits = r.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean);
+  checks.push({
+    name,
+    cmd: "secret-scan.sh",
+    result: hits.length > 0 ? "fail" : "pass",
+    duration_s: durationS,
+    ...hits.length > 0 ? { reason: `secret match: ${hits.join(", ")}` } : {}
+  });
+}
+function commentArgv(prNumber, bodyFile) {
+  return ["comment", prNumber, bodyFile];
+}
+function buildCommentBody(checks, notProven, statusState) {
+  const lines = [`## Loki deep verify: ${statusState}`, "", "### Checks"];
+  lines.push(...checks.length ? checks.map((c) => `- ${c.result}: ${c.name}${c.reason ? ` (${c.reason})` : ""}`) : ["- none"]);
+  lines.push("", "### NOT PROVEN", ...notProven.length ? notProven.map((n2) => `- ${n2}`) : ["- none"]);
+  return `${lines.join(`
+`)}
+`;
+}
+async function postResults(ctx, opts, checks, notProven, statusState) {
+  const out2 = [];
+  const pinnedOrigin = ctx.pinnedOrigin;
+  if (!pinnedOrigin) {
+    out2.push("push refused: no pinned origin (Rule of Two)");
+    return out2;
+  }
+  const scriptPath = opts.pushScriptPath ?? DEFAULT_PUSH_SH;
+  const env = { ...process.env, ...opts.pushExtraEnv, _LOKI_ORIGIN_PINNED: "1", _LOKI_PINNED_ORIGIN: pinnedOrigin };
+  const prUrl = ctx.outputs().pr?.pr_url;
+  const prNumber = prUrl ? PR_NUMBER_RE.exec(prUrl)?.[1] : undefined;
+  if (prNumber) {
+    mkdirSync17(ctx.runDir, { recursive: true });
+    const bodyFile = join48(ctx.runDir, "deep-comment.md");
+    writeFileSync18(bodyFile, buildCommentBody(checks, notProven, statusState), "utf8");
+    const commentResult = await run(["bash", scriptPath, ...commentArgv(prNumber, bodyFile)], { cwd: ctx.repoDir, env, timeoutMs: 30000 });
+    if (commentResult.exitCode !== 0)
+      out2.push(`deep comment not posted (engine10-push.sh exit ${commentResult.exitCode})`);
+  } else {
+    out2.push("deep comment not posted (no PR number)");
+  }
+  const headSha = (await safeGitRun(ctx.repoDir, ["rev-parse", "HEAD"], { timeoutMs: 1e4 })).stdout.trim();
+  if (SHA_RE.test(headSha)) {
+    const statusArgs = { cmd: "status", sha: headSha, state: statusState, description: `Loki 10 deep verify: ${statusState}` };
+    const statusResult = await run(["bash", scriptPath, ...pushArgv(statusArgs)], { cwd: ctx.repoDir, env, timeoutMs: 30000 });
+    if (statusResult.exitCode !== 0)
+      out2.push(`loki/deep-verify status not set (engine10-push.sh exit ${statusResult.exitCode})`);
+  } else {
+    out2.push("loki/deep-verify status not set (HEAD sha not resolvable)");
+  }
+  return out2;
+}
+async function runDeep(ctx, signal, opts = {}) {
+  if (signal.aborted)
+    return { status: "failed", data: {}, reason: "aborted before deep verify started" };
+  try {
+    assertWorkerEnv(opts.env ?? process.env);
+  } catch (err) {
+    return { status: "failed", data: {}, reason: err.message };
+  }
+  let changed;
+  try {
+    changed = changedFiles(ctx.repoDir, ctx.baseSha);
+  } catch (err) {
+    return { status: "failed", data: {}, reason: `git diff against base failed: ${err.message}` };
+  }
+  const checks = [];
+  const notProven = new Set;
+  await runFullSuite(ctx, signal, opts, checks, notProven);
+  runAppBoot(ctx, opts, checks, notProven);
+  await runCouncilCheck(ctx, changed, ctx.baseSha, signal, opts, checks, notProven);
+  await runSecretScan(ctx, changed, opts, checks, notProven);
+  const statusState = checks.some((c) => c.result === "fail") ? "failure" : "success";
+  const notProvenList = [...notProven];
+  const seal = ctx.outputs().seal;
+  const addendumBody = {
+    schema: "loki.v10.receipt-addendum/1",
+    run_id: ctx.runId,
+    base_receipt_sha256: seal?.receipt_sha256 ?? null,
+    checks,
+    not_proven: notProvenList,
+    status_state: statusState
+  };
+  const addendumSha256 = sha2562(canonicalJson(addendumBody));
+  const sig = signReceipt(`${ctx.runId}-deep`, addendumSha256);
+  const addendum = { ...addendumBody, addendum_sha256: addendumSha256, verification: { jwt: sig.jwt, kid: sig.kid } };
+  mkdirSync17(ctx.runDir, { recursive: true });
+  writeFileSync18(join48(ctx.runDir, "receipt-addendum-1.json"), JSON.stringify(addendum, null, 2) + `
+`);
+  const pushNotProven = await postResults(ctx, opts, checks, notProvenList, statusState);
+  const allNotProven = [...notProvenList, ...pushNotProven];
+  ctx.emit("deep.completed", "deep", { checks, status_state: statusState, addendum_sha256: addendumSha256 });
+  return { status: "completed", data: { checks, addendum_sha256: addendumSha256, status_state: statusState, not_proven: allNotProven } };
+}
+var DEFAULT_PUSH_SH, DEFAULT_SECRET_SCAN_SH, MAX_COUNCIL_DIFF_BYTES = 400000, FULL_SUITE_TIMEOUT_MS = 300000, PR_NUMBER_RE, SHA_RE, FULL_SUITE_CMD, deepStage, stage;
+var init_deep = __esm(() => {
+  init_project_graph();
+  init_shell();
+  init_load_owner();
+  init_worker();
+  init_seal();
+  init_verify();
+  init_package_suite();
+  init_check_result();
+  init_failures();
+  init_types();
+  init_safe_git();
+  DEFAULT_PUSH_SH = new URL("../../../../autonomy/lib/engine10-push.sh", import.meta.url).pathname;
+  DEFAULT_SECRET_SCAN_SH = new URL("../../../../autonomy/lib/secret-scan.sh", import.meta.url).pathname;
+  PR_NUMBER_RE = /\/pull\/(\d+)$/;
+  SHA_RE = /^[0-9a-f]{40}$/;
+  FULL_SUITE_CMD = {
+    pytest: { cmd: "python", args: ["-m", "pytest", "-q"] },
+    vitest: { cmd: "npx", args: ["vitest", "run"] },
+    jest: { cmd: "npx", args: ["jest"] },
+    bun: { cmd: "bun", args: ["test"] },
+    node: { cmd: "node", args: ["--test"] },
+    npm: { cmd: "npm", args: ["test", "--silent"] },
+    go: { cmd: "go", args: ["test", "-json", "./..."] },
+    cargo: { cmd: "cargo", args: ["test"] }
+  };
+  deepStage = {
+    name: "deep",
+    ...STAGE_BUDGETS.deep,
+    run: (ctx, signal) => runDeep(ctx, signal)
+  };
+  stage = deepStage;
+});
+
+// ../../loki-ts/src/engine10/stages/verify.ts
+import { existsSync as existsSync29, mkdtempSync as mkdtempSync6, realpathSync as realpathSync17, rmSync as rmSync12 } from "fs";
+import { tmpdir as tmpdir8 } from "os";
+import { dirname as dirname17, isAbsolute as isAbsolute6, join as join49, relative as relative5 } from "path";
+function resolveTool(repoDir, bin, fallback, lastResort = fallback) {
+  const inRepo = (p) => {
+    try {
+      const r = relative5(realpathSync17(repoDir), realpathSync17(p));
+      return r !== "" && !r.startsWith("..") && !isAbsolute6(r);
+    } catch {
+      return false;
+    }
+  };
+  const venvEnv = process.env["VIRTUAL_ENV"];
+  const project = [join49(repoDir, ".venv", "bin", bin), join49(repoDir, "venv", "bin", bin), ...venvEnv && inRepo(venvEnv) ? [join49(venvEnv, "bin", bin)] : []].find(existsSync29);
+  return project ? [project, "project"] : [Bun.which(fallback) ? fallback : lastResort, "system"];
+}
+function runnerCmd(t, repoDir) {
+  switch (t.runner) {
+    case "pytest": {
+      const [cmd, interpreter] = resolveTool(repoDir, "python", "python3", "python");
+      return [cmd, ["-m", "pytest", "-q", t.path], interpreter];
+    }
+    case "vitest":
+      return ["npx", ["vitest", "run", t.path]];
+    case "jest":
+      return ["npx", ["jest", t.path]];
+    case "bun":
+      return ["bun", ["test", t.path]];
+    case "node":
+      return ["node", ["--test", `./${t.path}`]];
+    case "npm":
+      return ["npm", ["test", "--silent"]];
+    case "go":
+      return ["go", ["test", "-json", `./${dirname17(t.path)}`]];
+    case "cargo":
+      return ["cargo", ["test"]];
+  }
+}
+function commandFor(t, repoDir, api) {
+  const site = siteFor(api, repoDir, t.path);
+  const [cmd, args, interpreter] = runnerCmd(site ? { runner: t.runner, path: site.file } : t, repoDir);
+  return { cwd: site?.cwd ?? repoDir, cmd, args, argv: [cmd, ...args], ...interpreter ? { interpreter } : {}, pkgRoot: site?.root ?? "." };
+}
+function testConfigChanged(repoDir, baseSha, changed) {
+  const diff = (f) => safeGit(repoDir, ["diff", "-U0", baseSha, "--", f]);
+  return changed.filter((f) => CFG_ALWAYS.test(f) || CFG_SHARED.test(f) && (() => {
+    const d = diff(f);
+    return !d || CFG_LINE.test(d);
+  })());
+}
+async function runOnce(cmd, args, cwd, signal, opts) {
+  if (!Bun.which(cmd, { PATH: opts.path ?? process.env["PATH"] ?? "" }))
+    return { ok: false, missing: true, cut: false, out: "" };
+  const timeout = AbortSignal.timeout(opts.timeoutMs ?? CHECK_TIMEOUT_MS);
+  const proc = Bun.spawn([cmd, ...args], {
+    cwd,
+    stdin: opts.stdin !== undefined ? Buffer.from(opts.stdin) : "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    signal: AbortSignal.any([signal, timeout]),
+    env: opts.path ? { ...plainTestEnv(), PATH: opts.path } : plainTestEnv()
+  });
+  let tail = "";
+  const rs = [proc.stdout, proc.stderr].map((s) => s.getReader());
+  const pumps = rs.map(async (r) => {
+    const d = new TextDecoder;
+    for (;; ) {
+      const c = await r.read().catch(() => ({ done: true, value: undefined }));
+      if (c.done)
+        return;
+      tail = (tail + d.decode(c.value, { stream: true })).slice(-65536);
+    }
+  });
+  const exitCode = await proc.exited;
+  await Promise.race([Promise.all(pumps), new Promise((r) => setTimeout(r, 300))]);
+  rs.forEach((r) => r.cancel().catch(() => {}));
+  const cut = timeout.aborted || signal.aborted;
+  return { ok: exitCode === 0 && !cut, missing: false, cut, out: cut ? "" : stripAnsi(tail) };
+}
+function firstError(out2) {
+  const goOut = (l2) => {
+    try {
+      const e = JSON.parse(l2);
+      return typeof e.Action === "string" ? e.Action === "output" || e.Action === "build-output" ? e.Output ?? "" : "" : l2;
+    } catch {
+      return l2;
+    }
+  };
+  const lines = out2.slice(-65536).split(`
+`).map((l2) => (l2.startsWith("{") ? goOut(l2) : l2).trim()).filter(Boolean), l = lines.find((x) => /^(FAILED\s|\u25cf\s.*\u203a|not ok\s|_{3,}\s.+\s_{3,}$)/.test(x)) ?? lines.find((x) => /^[\w./-]+\.go:\d+:\d+: \S/.test(x)) ?? lines.find((x) => /fail|error/i.test(x) && !/^(=|\u2713|ok\b|PASS)/.test(x)) ?? "";
+  return l.replace(/\d{4}-\d\d-\d\dT[\d:.]+Z?/g, "").replace(/(^|\s)\/(?:[\w.@-]+\/)*[\w.@-]+/g, "$1<path>").replace(/:\d+(?::\d+)?/g, "").replace(/\[?\d+(?:\.\d+)?m?s\]?/g, "").replace(/\s+/g, " ").slice(0, 160);
+}
+async function runCheck(ctx, name, cmd, args, signal, checks, opts = {}) {
+  const started = Date.now();
   const cmdStr = [cmd, ...args].join(" ");
   const kind = opts.kind ?? "test";
   const cwd = opts.cwd ?? ctx.repoDir;
@@ -10701,7 +11995,7 @@ async function subtractBase(ctx, api, checks, tests, changed, wall, rel, signal)
   const sus = pairs.filter(({ c }) => rel.has(c.name) && c.result === "pass");
   if (!(un.some(({ c }) => c.result === "fail" && c.ids?.length) || sus.length) || signal.aborted)
     return out2;
-  const dir = mkdtempSync6(join41(tmpdir8(), "e10-base-"));
+  const dir = mkdtempSync6(join49(tmpdir8(), "e10-base-"));
   const git3 = (args) => {
     safeGit(ctx.repoDir, args, { stdio: "ignore", repoDrivers: true });
   };
@@ -10728,7 +12022,7 @@ async function subtractBase(ctx, api, checks, tests, changed, wall, rel, signal)
     try {
       git3(["worktree", "remove", "--force", dir]);
     } catch {}
-    rmSync9(dir, { recursive: true, force: true });
+    rmSync12(dir, { recursive: true, force: true });
     try {
       git3(["worktree", "prune"]);
     } catch {}
@@ -10736,7 +12030,7 @@ async function subtractBase(ctx, api, checks, tests, changed, wall, rel, signal)
   return out2;
 }
 function isLokiModeRepo(repoDir) {
-  return existsSync22(join41(repoDir, "scripts", "select-tests.sh"));
+  return existsSync29(join49(repoDir, "scripts", "select-tests.sh"));
 }
 async function runLintChecks(ctx, changed, signal, checks, opts = {}) {
   const { api, ...runOpts } = opts;
@@ -10753,9 +12047,9 @@ async function runLintChecks(ctx, changed, signal, checks, opts = {}) {
   }
   for (const g of groupByPackage(api, ctx.repoDir, changed.filter((f) => /\.(ts|tsx|js|jsx)$/.test(f)))) {
     const sfx = g.root === "." ? "" : `:${g.root}`, co = g.root === "." ? opts : { ...opts, cwd: g.cwd };
-    if (existsSync22(join41(g.cwd, "tsconfig.json")))
+    if (existsSync29(join49(g.cwd, "tsconfig.json")))
       await runCheck(ctx, `lint:tsc${sfx}`, "npx", ["tsc", "--noEmit", "-p", "."], signal, checks, { ...co, kind: "static" });
-    if (ESLINT_CONFIGS.some((f) => existsSync22(join41(g.cwd, f))))
+    if (ESLINT_CONFIGS.some((f) => existsSync29(join49(g.cwd, f))))
       await runCheck(ctx, `lint:eslint${sfx}`, "npx", ["eslint", ...g.rel], signal, checks, { ...co, kind: "static" });
   }
 }
@@ -10772,6 +12066,8 @@ var init_verify = __esm(() => {
   init_types();
   init_resolve();
   init_safe_git();
+  init_repo_profile();
+  init_check_result();
   init_check_result();
   CODE_EXT = /\.(?:[cm]?[jt]sx?|py|go)$/;
   CFG_ALWAYS = /(^|\/)(conftest\.py|\.?pytest\.(?:ini|toml)|tox\.ini|jest\.config\.[\w.]+|vitest\.config\.[\w.]+|\.mocharc[\w.]*)$/;
@@ -10796,13 +12092,22 @@ var init_verify = __esm(() => {
         }
         return { status: "failed", data: { changed_files: [] }, reason: "empty diff without an already_done marker" };
       }
+      let risk = (() => {
+        try {
+          const r = classifyRisk(diffFiles(ctx.repoDir, ctx.baseSha));
+          recordRisk(ctx.repoDir, r);
+          return r;
+        } catch {
+          return null;
+        }
+      })();
       const checks = [];
       const api = loadProjectApi(ctx.repoDir);
       const map = await ctx.tests.detect(ctx.repoDir);
       const impacted = ctx.tests.impacted(map, changed);
       const changedTestFiles = map.tests.filter((t) => changed.includes(t.path));
       const wall = ctx.outputs().wall ?? {};
-      const wallPaths = new Set((wall.files ?? []).map((f) => isAbsolute5(f.path) ? relative5(ctx.repoDir, f.path) : f.path));
+      const wallPaths = new Set((wall.files ?? []).map((f) => isAbsolute6(f.path) ? relative5(ctx.repoDir, f.path) : f.path));
       const wallTests = map.tests.filter((t) => wallPaths.has(t.path));
       const intake = ctx.outputs().intake, relevant = ctx.tests.impacted(map, namedFiles(intake?.task ?? "", loadRepoMap(intake?.repomap_ref)));
       const tests = dedupeTests([...impacted, ...changedTestFiles, ...wallTests, ...relevant]);
@@ -10817,6 +12122,9 @@ var init_verify = __esm(() => {
       }
       const targetNames = new Set([...wallTests, ...relevant].map((t) => `${t.runner}:${t.path}`));
       const preRed = await subtractBase(ctx, api, checks, tests, changed, new Set(wallTests.map((t) => `${t.runner}:${t.path}`)), new Set(relevant.map((t) => `${t.runner}:${t.path}`)), signal);
+      const attr = attribute(ctx.repoDir, ctx.baseSha, checks.filter((c) => c.result === "fail" && !preRed.names.includes(c.name)).map((c) => ({ name: c.name, ids: c.ids, eligible: !targetNames.has(c.name) && !changed.includes(c.name.slice(c.name.indexOf(":") + 1)) })));
+      preRed.names.push(...attr.preExistingChecks);
+      preRed.ids.push(...attr.preExistingIds);
       if (!signal.aborted) {
         await runLintChecks(ctx, changed, signal, checks, { api, wall: wallPaths });
         if (isLokiModeRepo(ctx.repoDir)) {
@@ -10828,6 +12136,23 @@ var init_verify = __esm(() => {
           });
         }
       }
+      const fullNotProven = new Set;
+      if (risk && risk.tier !== "low" && !signal.aborted) {
+        const { runFullSuite: runFullSuite2 } = await Promise.resolve().then(() => (init_deep(), exports_deep));
+        const full = [];
+        await runFullSuite2(ctx, signal, {}, full, fullNotProven);
+        for (const c of full)
+          checks.push({ name: c.name, cmd: c.cmd, result: c.result, duration_s: c.duration_s, ...c.reason ? { reason: c.reason } : {} });
+        const fa = attributeFullSuite(ctx.repoDir, ctx.baseSha, full, checks.filter((c) => c.result === "fail" && !preRed.names.includes(c.name)).flatMap((c) => c.ids ?? []), changed);
+        preRed.names.push(...fa.preExistingChecks);
+        preRed.ids.push(...fa.preExistingIds);
+        attr.introducedChecks.push(...fa.introducedChecks);
+        attr.line = [attr.line, fa.line].filter(Boolean).join("; ") || null;
+        if (full.some((c) => c.result === "pass" || c.result === "fail")) {
+          risk = markExecuted(risk, ["full test command", "full suite"]);
+          recordRisk(ctx.repoDir, risk);
+        }
+      }
       const cfgChanged = testConfigChanged(ctx.repoDir, ctx.baseSha, changed);
       const covered = (f) => ctx.tests.impacted(map, [f]).some((t) => checks.some((c) => c.name === `${t.runner}:${t.path}` && hasExecutedProof([c])));
       const uncoveredChanged = changed.filter((f) => CODE_EXT.test(f) && !isTestFile(f) && !wallPaths.has(f) && !cfgChanged.includes(f) && !covered(f));
@@ -10849,15 +12174,15 @@ var init_verify = __esm(() => {
         return [`weakened test: ${t.path}`, ...assertDeltaNotes(ctx.repoDir, ctx.baseSha, null, t.path, intake?.task ?? "", k?.b, k?.h) ?? []];
       });
       const weakened = [...modifiedRel, ...cfgChanged.map((f) => `test configuration changed: ${f}`), ...preRed.weak.map((n2) => `skipped or fewer tests than base: ${n2}`)];
-      const notProven = [...weakened, ...checks.filter((c) => c.owner === "harness").map((c) => `${c.reason} (${c.name}; harness-owned, no fix rounds)`), ...new Set(checks.filter((c) => c.interpreter === "system" && c.result !== "not_run").map((c) => c.name.startsWith("lint:") ? "lint ran on the system ruff" : "tests ran on the system interpreter"))];
-      return { status: "completed", data: { checks, flaky, failures_grouped: failuresGrouped, changed_files: changed, not_proven: notProven, pre_red: preRed.ids, pre_red_checks: preRed.names, test_counts: testCounts, uncovered_changed: uncoveredChanged, target_checks: checks.filter((c) => c.result === "pass" && targetNames.has(c.name)).map((c) => c.name) } };
+      const notProven = [...weakened, ...[...fullNotProven].filter((n2) => !n2.startsWith("full suite (no test runner")), ...checks.filter((c) => c.owner === "harness").map((c) => `${c.reason} (${c.name}; harness-owned, no fix rounds)`), ...new Set(checks.filter((c) => c.interpreter === "system" && c.result !== "not_run").map((c) => c.name.startsWith("lint:") ? "lint ran on the system ruff" : "tests ran on the system interpreter"))];
+      return { status: "completed", data: { checks, flaky, failures_grouped: failuresGrouped, changed_files: changed, not_proven: notProven, pre_red: preRed.ids, pre_red_checks: preRed.names, ...attr.line ? { baseline_line: attr.line, introduced_checks: attr.introducedChecks } : {}, test_counts: testCounts, uncovered_changed: uncoveredChanged, target_checks: checks.filter((c) => c.result === "pass" && targetNames.has(c.name)).map((c) => c.name), risk } };
     }
   };
 });
 
 // ../../loki-ts/src/project_model/conventions.ts
-import { existsSync as existsSync23, readdirSync as readdirSync12, readFileSync as readFileSync28 } from "fs";
-import { dirname as dirname13, join as join42 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync14, readFileSync as readFileSync35 } from "fs";
+import { dirname as dirname18, join as join50 } from "path";
 function parseJsonc(text3) {
   let out2 = "", i = 0;
   while (i < text3.length) {
@@ -10892,25 +12217,25 @@ function moduleOf(file, depth = 0) {
   const ext = typeof j.extends === "string" ? j.extends : null;
   if (!ext || !ext.startsWith("."))
     return null;
-  const next = join42(dirname13(file), ext.endsWith(".json") ? ext : `${ext}.json`);
-  return existsSync23(next) ? moduleOf(next, depth + 1) : null;
+  const next = join50(dirname18(file), ext.endsWith(".json") ? ext : `${ext}.json`);
+  return existsSync30(next) ? moduleOf(next, depth + 1) : null;
 }
 function readPackageConventions(pkgDir, runner = null) {
   let names = [];
   try {
-    names = readdirSync12(pkgDir).filter((f) => f.endsWith(".json")).sort((x, y) => x.length - y.length || x.localeCompare(y));
+    names = readdirSync14(pkgDir).filter((f) => f.endsWith(".json")).sort((x, y) => x.length - y.length || x.localeCompare(y));
   } catch {
     return null;
   }
   let packageType = null, tsModule = null;
   for (const n2 of names) {
-    const j = readJson5(join42(pkgDir, n2));
+    const j = readJson5(join50(pkgDir, n2));
     if (!j)
       continue;
     if (packageType === null && typeof j.type === "string" && typeof j.name === "string")
       packageType = j.type;
     if (tsModule === null && j.compilerOptions !== undefined)
-      tsModule = moduleOf(join42(pkgDir, n2));
+      tsModule = moduleOf(join50(pkgDir, n2));
   }
   if (packageType === null && tsModule === null)
     return null;
@@ -10932,7 +12257,7 @@ function conventionViolation(c, fileName, content) {
 }
 var readJson5 = (p) => {
   try {
-    const v = parseJsonc(readFileSync28(p, "utf8"));
+    const v = parseJsonc(readFileSync35(p, "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : null;
   } catch {
     return null;
@@ -10942,15 +12267,15 @@ var init_conventions = () => {};
 
 // ../../loki-ts/src/engine10/stages/wall.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync7, readFileSync as readFileSync29, readdirSync as readdirSync13, realpathSync as realpathSync17, rmSync as rmSync10, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync7, readFileSync as readFileSync36, readdirSync as readdirSync15, realpathSync as realpathSync18, rmSync as rmSync13, writeFileSync as writeFileSync19 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
-import { dirname as dirname14, isAbsolute as isAbsolute6, join as join43, relative as relative6 } from "path";
+import { dirname as dirname19, isAbsolute as isAbsolute7, join as join51, relative as relative6 } from "path";
 function pytestCollectionIsRed(output, repoDir) {
   if (/ModuleNotFoundError/.test(output))
     return false;
   const real2 = (p) => {
     try {
-      return realpathSync17(isAbsolute6(p) ? p : join43(repoDir, p));
+      return realpathSync18(isAbsolute7(p) ? p : join51(repoDir, p));
     } catch {
       return null;
     }
@@ -10987,7 +12312,7 @@ function pytestCollectionIsRed(output, repoDir) {
 }
 function moduleUnderRepo(repoDir, name) {
   const rel = name.replace(/\./g, "/");
-  return existsSync24(join43(repoDir, `${rel}.py`)) || existsSync24(join43(repoDir, rel, "__init__.py"));
+  return existsSync31(join51(repoDir, `${rel}.py`)) || existsSync31(join51(repoDir, rel, "__init__.py"));
 }
 function pytestExit1IsRed(output) {
   if (/^!+ _pytest\.outcomes\.Exit\b/m.test(output))
@@ -11082,10 +12407,10 @@ ${repomapText}`] : [],
 function loadTaskText(ctx, fromPrior) {
   if (fromPrior)
     return fromPrior;
-  const issueJsonPath = process.env.LOKI_E10_ISSUE_JSON ?? join43(ctx.runDir, "issue.json");
-  if (existsSync24(issueJsonPath)) {
+  const issueJsonPath = process.env.LOKI_E10_ISSUE_JSON ?? join51(ctx.runDir, "issue.json");
+  if (existsSync31(issueJsonPath)) {
     try {
-      const issue = JSON.parse(readFileSync29(issueJsonPath, "utf8"));
+      const issue = JSON.parse(readFileSync36(issueJsonPath, "utf8"));
       const text3 = [issue.title, issue.body].filter((s) => typeof s === "string" && s.length > 0).join(`
 
 `);
@@ -11097,7 +12422,7 @@ function loadTaskText(ctx, fromPrior) {
 }
 function wallTargetDir(repoDir, existingTests) {
   const first = existingTests[0];
-  return first ? join43(repoDir, dirname14(first.path)) : join43(repoDir, "tests");
+  return first ? join51(repoDir, dirname19(first.path)) : join51(repoDir, "tests");
 }
 function guessRunner(fileName, runners) {
   if (fileName.endsWith(".py"))
@@ -11128,11 +12453,11 @@ async function wallAuthor(ctx, signal) {
   const tree = prior.intake?.tree;
   const repomapText = repoMapText(ctx.repoDir, tree, repomapRef, WALL_MAP_MAX_LINES);
   const targetDir = wallTargetDir(ctx.repoDir, existingTests), pkg = loadProjectApi(ctx.repoDir)?.packageOf(`${relative6(ctx.repoDir, targetDir)}/x`);
-  const conv2 = readPackageConventions(join43(ctx.repoDir, pkg?.root ?? "."), pkg?.runner ?? null);
-  const cwd = mkdtempSync7(join43(tmpdir9(), "loki-e15-wall-"));
+  const conv2 = readPackageConventions(join51(ctx.repoDir, pkg?.root ?? "."), pkg?.runner ?? null);
+  const cwd = mkdtempSync7(join51(tmpdir9(), "loki-e15-wall-"));
   const wm = wallManifestFor(ctx.repoDir, tree, task);
   for (const [n2, c] of [["task.md", task], ["repomap.txt", repomapText], ...wm ? [["wall_manifest.txt", wm.text]] : []])
-    writeFileSync13(join43(cwd, n2), c, "utf8");
+    writeFileSync19(join51(cwd, n2), c, "utf8");
   const session = await ctx.sessions.run({
     stage: "wall",
     brief: buildWallBrief(task, repomapText, runners, !!wm, conventionsBrief(conv2)),
@@ -11144,30 +12469,30 @@ async function wallAuthor(ctx, signal) {
     cwd
   });
   if (session.killed || session.exit === null) {
-    rmSync10(cwd, { recursive: true, force: true });
+    rmSync13(cwd, { recursive: true, force: true });
     return done({ status: "failed", data: {}, reason: "wall session aborted, killed, or timed out", killed: true });
   }
-  const generated = readdirSync13(cwd).filter((f) => f.startsWith(WALL_PREFIX));
-  const sealedDir = join43(ctx.runDir, "wall");
+  const generated = readdirSync15(cwd).filter((f) => f.startsWith(WALL_PREFIX));
+  const sealedDir = join51(ctx.runDir, "wall");
   if (generated.length > 0)
-    mkdirSync10(sealedDir, { recursive: true });
+    mkdirSync18(sealedDir, { recursive: true });
   const contents = new Map;
   const discarded = [];
   for (const name of generated) {
-    const content = readFileSync29(join43(cwd, name), "utf8"), bad = conventionViolation(conv2, name, content);
-    writeFileSync13(join43(sealedDir, name), content, "utf8");
+    const content = readFileSync36(join51(cwd, name), "utf8"), bad = conventionViolation(conv2, name, content);
+    writeFileSync19(join51(sealedDir, name), content, "utf8");
     if (bad)
       discarded.push({ file: name, reason: `${bad}; wall test did not compile under the package config` });
     else
       contents.set(name, content);
   }
-  rmSync10(cwd, { recursive: true, force: true });
+  rmSync13(cwd, { recursive: true, force: true });
   return { kind: "authored", task, sizeName: sz.size, runners, targetDir, generated, contents, discarded, ...wm ? { manifestSha256: wm.sha256 } : {} };
 }
 function installWall(ctx, a, baseDir, opts = {}) {
   const { generated, contents, discarded, targetDir, runners } = a;
   if (generated.length > 0)
-    mkdirSync10(targetDir, { recursive: true });
+    mkdirSync18(targetDir, { recursive: true });
   const sealedFiles = [];
   const readOnlyFiles = [];
   const wallTests = [];
@@ -11175,8 +12500,8 @@ function installWall(ctx, a, baseDir, opts = {}) {
     const content = contents.get(name);
     if (content === undefined)
       continue;
-    const dest = join43(targetDir, name), runner = guessRunner(name, runners);
-    writeFileSync13(dest, content, "utf8");
+    const dest = join51(targetDir, name), runner = guessRunner(name, runners);
+    writeFileSync19(dest, content, "utf8");
     sealedFiles.push({ path: dest, sha256: sha2562(content) });
     readOnlyFiles.push({ path: dest, content });
     if (runner)
@@ -11185,13 +12510,13 @@ function installWall(ctx, a, baseDir, opts = {}) {
   ctx.emit("wall.sealed", "wall", { files: sealedFiles, ...a.manifestSha256 ? { manifest_sha256: a.manifestSha256 } : {} });
   const baseRunner = opts.baseRunner ?? new RealBaseTestRunner, baseRun = { pass: 0, fail: 0, not_run: discarded.length }, notRunFiles = [];
   for (const t of wallTests) {
-    const r = baseRunner.run(baseDir, [t]), abs = join43(ctx.repoDir, t.path);
+    const r = baseRunner.run(baseDir, [t]), abs = join51(ctx.repoDir, t.path);
     baseRun.pass += r.pass;
     baseRun.fail += r.fail;
     baseRun.not_run += r.not_run ?? 0;
     notRunFiles.push(...baseRunner.lastNotRunFiles ?? []);
     if (r.pass + r.fail === 0) {
-      rmSync10(abs, { force: true });
+      rmSync13(abs, { force: true });
       for (const l of [sealedFiles, readOnlyFiles])
         l.splice(0, l.length, ...l.filter((f) => f.path !== abs));
     }
@@ -11215,7 +12540,7 @@ async function runWall(ctx, signal, opts = {}) {
   const a = await wallAuthor(ctx, signal);
   return a.kind === "done" ? a.result : installWall(ctx, a, ctx.repoDir, opts);
 }
-var WALL_PREFIX = "loki_wall_", BASE_RUN_TIMEOUT_MS = 60000, WALL_MAP_MAX_LINES = 200, wallStage, stage;
+var WALL_PREFIX = "loki_wall_", BASE_RUN_TIMEOUT_MS = 60000, WALL_MAP_MAX_LINES = 200, wallStage, stage2;
 var init_wall = __esm(() => {
   init_types();
   init_lean_prefix();
@@ -11232,24 +12557,24 @@ var init_wall = __esm(() => {
     limitS: 300,
     run: (ctx, signal) => runWall(ctx, signal)
   };
-  stage = Object.assign(wallStage, { split: { author: wallAuthor, install: installWall } });
+  stage2 = Object.assign(wallStage, { split: { author: wallAuthor, install: installWall } });
 });
 
 // ../../loki-ts/src/e10ext/discard.ts
-import { chmodSync as chmodSync4, closeSync as closeSync6, lstatSync as lstatSync7, mkdirSync as mkdirSync11, openSync as openSync6, readFileSync as readFileSync30, realpathSync as realpathSync18, rmdirSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname15, join as join44, relative as relative7, sep as sep11 } from "path";
+import { chmodSync as chmodSync4, closeSync as closeSync8, lstatSync as lstatSync10, mkdirSync as mkdirSync19, openSync as openSync8, readFileSync as readFileSync37, realpathSync as realpathSync19, rmdirSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname20, join as join52, relative as relative7, sep as sep11 } from "path";
 function safeRestore(repoDir, f, want, mode) {
-  const root = realpathSync18(repoDir), fp = join44(root, f), rel = relative7(root, dirname15(fp));
+  const root = realpathSync19(repoDir), fp = join52(root, f), rel = relative7(root, dirname20(fp));
   if (rel.startsWith(".."))
     throw new Error("outside repo");
   let cur = root;
   for (const part of rel === "" ? [] : rel.split(sep11)) {
-    cur = join44(cur, part);
+    cur = join52(cur, part);
     let st2;
     try {
-      st2 = lstatSync7(cur);
+      st2 = lstatSync10(cur);
     } catch {
-      mkdirSync11(cur);
+      mkdirSync19(cur);
       continue;
     }
     if (!st2.isDirectory())
@@ -11257,11 +12582,11 @@ function safeRestore(repoDir, f, want, mode) {
   }
   let st;
   try {
-    st = lstatSync7(fp);
+    st = lstatSync10(fp);
   } catch {
     st = null;
   }
-  if (st?.isFile() && readFileSync30(fp).equals(want)) {
+  if (st?.isFile() && readFileSync37(fp).equals(want)) {
     chmodSync4(fp, mode);
     return;
   }
@@ -11269,13 +12594,13 @@ function safeRestore(repoDir, f, want, mode) {
     if (st.isDirectory())
       rmdirSync(fp);
     else
-      unlinkSync3(fp);
+      unlinkSync4(fp);
   }
-  const fd = openSync6(fp, "wx", mode);
+  const fd = openSync8(fp, "wx", mode);
   try {
-    writeFileSync14(fd, want);
+    writeFileSync20(fd, want);
   } finally {
-    closeSync6(fd);
+    closeSync8(fd);
   }
   chmodSync4(fp, mode);
 }
@@ -11299,10 +12624,10 @@ async function discardIfSatisfied(git3, base, o, staged, keep, repoDir) {
     return { status: "failed", data: {}, reason: "already-satisfied discard failed" };
   const notProven = [];
   for (const [f, v] of Object.entries(o.intake?.preexisting_untracked_blobs ?? {})) {
-    const fp = join44(repoDir, f);
+    const fp = join52(repoDir, f);
     try {
       if (v.startsWith("!")) {
-        const st = lstatSync7(fp);
+        const st = lstatSync10(fp);
         if (`!${st.size}:${st.mtimeMs}:${st.ctimeMs}` !== v)
           throw new Error("changed, not snapshotted");
         continue;
@@ -11318,7 +12643,7 @@ async function discardIfSatisfied(git3, base, o, staged, keep, repoDir) {
       try {
         let m = 420;
         try {
-          const l = lstatSync7(join44(repoDir, f));
+          const l = lstatSync10(join52(repoDir, f));
           if (l.isFile())
             m = l.mode & 511;
         } catch {}
@@ -11351,9 +12676,9 @@ var init_preexisting_dirty = __esm(() => {
 });
 
 // ../../loki-ts/src/e10ext/commit_filter.ts
-import { dirname as dirname16 } from "path";
+import { dirname as dirname21 } from "path";
 function dropSet(repoDir, staged, preexistingDirty, env = process.env) {
-  return staged.concat(untouchedSinceIntake(repoDir, preexistingDirty, env).map((f) => ({ st: "L", f }))).filter(({ st, f }) => f.startsWith(".loki/") || st === "L" || /(^|\/)loki_wall_[^/]*$/.test(f) || st === "A" && !staged.some(({ f: m }) => /(^|\/)(package\.json|pyproject\.toml|requirements\.txt|Cargo\.toml|go\.mod)$/.test(m) && dirname16(m) === dirname16(f)) && /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|poetry\.lock|Cargo\.lock|go\.sum)$/.test(f));
+  return staged.concat(untouchedSinceIntake(repoDir, preexistingDirty, env).map((f) => ({ st: "L", f }))).filter(({ st, f }) => f.startsWith(".loki/") || st === "L" || /(^|\/)loki_wall_[^/]*$/.test(f) || st === "A" && !staged.some(({ f: m }) => /(^|\/)(package\.json|pyproject\.toml|requirements\.txt|Cargo\.toml|go\.mod)$/.test(m) && dirname21(m) === dirname21(f)) && /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|poetry\.lock|Cargo\.lock|go\.sum)$/.test(f));
 }
 var parseStaged = (out2) => out2.split("\x00").reduce((a, t, i, all) => i % 2 === 0 && t ? [...a, { st: t, f: all[i + 1] }] : a, []);
 var init_commit_filter = __esm(() => {
@@ -11361,73 +12686,8 @@ var init_commit_filter = __esm(() => {
   init_safe_git();
 });
 
-// ../../loki-ts/src/features/speed/unit_mode.ts
-import { closeSync as closeSync7, constants as constants2, fstatSync as fstatSync4, lstatSync as lstatSync8, openSync as openSync7, readSync as readSync5, realpathSync as realpathSync19 } from "fs";
-function readBounded(path) {
-  const l = lstatSync8(path);
-  if (l.isSymbolicLink() || !l.isFile() || l.size > MAX_SPEC_BYTES)
-    return null;
-  const fd = openSync7(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
-  try {
-    const st = fstatSync4(fd);
-    if (!st.isFile() || st.size > MAX_SPEC_BYTES)
-      return null;
-    const buf = Buffer.alloc(st.size + 1);
-    let n2 = 0;
-    for (;; ) {
-      const r = readSync5(fd, buf, n2, buf.length - n2, null);
-      if (r <= 0)
-        break;
-      n2 += r;
-      if (n2 >= buf.length)
-        return null;
-    }
-    return buf.subarray(0, n2).toString("utf8");
-  } finally {
-    closeSync7(fd);
-  }
-}
-function parseText(txt) {
-  try {
-    const j = JSON.parse(txt), ws = strs(j.writeSet), pack = strs(j.pack), tb = j.tokenBudget;
-    if (typeof j.id !== "string" || !j.id || !ws || ws.length === 0 || !pack || typeof tb !== "number" || !Number.isFinite(tb) || !(tb > 0) || tb > MAX_TOKEN_BUDGET)
-      return null;
-    return { id: j.id, writeSet: ws, pack, tokenBudget: tb };
-  } catch {
-    return null;
-  }
-}
-function parseSpec(path) {
-  try {
-    const txt = readBounded(path);
-    return txt === null ? null : parseText(txt);
-  } catch {
-    return null;
-  }
-}
-function unitSpec(env = process.env) {
-  const path = env["LOKI_UNIT_SPEC"], frozen = env["LOKI_UNIT_SPEC_FROZEN"];
-  if (env["LOKI_SPEED"] === "0" || !path)
-    return null;
-  if (frozen !== undefined)
-    return frozen.length <= MAX_SPEC_BYTES ? parseText(frozen) : null;
-  if (!memo.has(path))
-    memo.set(path, parseSpec(path));
-  return memo.get(path) ?? null;
-}
-function unitFlags(staged, env = process.env, pre = {}) {
-  const s = unitSpec(env);
-  return s ? staged.filter(({ f }) => !inWriteSet(s, f) && !Object.hasOwn(pre, f)).map(({ f }) => f) : null;
-}
-var MAX_SPEC_BYTES, MAX_TOKEN_BUDGET = 1e9, norm3 = (p) => p.replace(/^\.\//, ""), CTRL, strs = (v) => Array.isArray(v) && v.every((x) => typeof x === "string" && !CTRL.test(x)) ? v.map(norm3) : null, memo, inWriteSet = (spec, f) => spec.writeSet.some((w) => w.endsWith("/") ? f.startsWith(w) : f === w);
-var init_unit_mode = __esm(() => {
-  MAX_SPEC_BYTES = 1024 * 1024;
-  CTRL = /[\x00-\x1f\x7f]/;
-  memo = new Map;
-});
-
 // ../../loki-ts/src/e10ext/scope.ts
-import { basename as basename16, dirname as dirname17 } from "path";
+import { basename as basename18, dirname as dirname22 } from "path";
 function contractText(o) {
   const c = o.intake?.contract_snapshot?.contract;
   return Array.isArray(c?.criteria) ? c.criteria.map((x) => typeof x?.text === "string" ? x.text : "").join(`
@@ -11441,8 +12701,8 @@ function outsideScope(o, staged) {
   const text3 = `${plan}
 ${typeof o.intake?.task === "string" ? o.intake.task : ""}
 ${contractText(o)}`, pre = o.intake?.preexisting_dirty ?? {};
-  const toks = surfaceTokens(text3), plannedDirs = new Set(rel.map((r) => dirname17(r)).filter((d) => d !== "."));
-  return staged.filter(({ st, f }) => st !== "A" && !isTestFile(f) && !Object.hasOwn(pre, f) && !rel.includes(f) && !mentions(text3, f) && !mentions(text3, basename16(f)) && !plannedDirs.has(dirname17(f)) && !dirSegs(f).some((d) => toks.has(d))).map(({ f }) => f);
+  const toks = surfaceTokens(text3), plannedDirs = new Set(rel.map((r) => dirname22(r)).filter((d) => d !== "."));
+  return staged.filter(({ st, f }) => st !== "A" && !isTestFile(f) && !Object.hasOwn(pre, f) && !rel.includes(f) && !mentions(text3, f) && !mentions(text3, basename18(f)) && !plannedDirs.has(dirname22(f)) && !dirSegs(f).some((d) => toks.has(d))).map(({ f }) => f);
 }
 function flagOutsideScope(o, staged) {
   const unit = unitFlags(staged, process.env, o.intake?.preexisting_dirty ?? {});
@@ -11457,101 +12717,77 @@ var init_scope2 = __esm(() => {
 });
 
 // ../../loki-ts/src/util/receipt_signer.ts
-var RECEIPT_SIGNER_BASENAME = "receipt-ed25519.pem";
-
-// ../../loki-ts/src/util/atomic.ts
-import {
-  closeSync as closeSync8,
-  fstatSync as fstatSync5,
-  fsyncSync as fsyncSync2,
-  lstatSync as lstatSync9,
-  mkdirSync as mkdirSync12,
-  openSync as openSync8,
-  readSync as readSync6,
-  renameSync as renameSync5,
-  rmSync as rmSync11,
-  statSync as statSync15,
-  unlinkSync as unlinkSync4,
-  writeSync as writeSync3
-} from "fs";
-import { dirname as dirname18 } from "path";
-function durableWriteThenRename(target, body) {
-  mkdirSync12(dirname18(target), { recursive: true });
-  const tmp = `${target}.tmp.${process.pid}.${++_tmpCounter}`;
-  const fd = openSync8(tmp, "w");
-  try {
-    writeSync3(fd, body);
-    fsyncSync2(fd);
-  } finally {
-    closeSync8(fd);
-  }
-  renameSync5(tmp, target);
-  fsyncParentDir(target);
-}
-function fsyncParentDir(target) {
-  let dfd = null;
-  try {
-    dfd = openSync8(dirname18(target), "r");
-    fsyncSync2(dfd);
-  } catch {} finally {
-    if (dfd !== null) {
-      try {
-        closeSync8(dfd);
-      } catch {}
+import { createHash as createHash11, randomBytes as randomBytes3, createPrivateKey, createPublicKey as createPublicKey2, generateKeyPairSync, sign } from "crypto";
+import { chmodSync as chmodSync5, linkSync, mkdirSync as mkdirSync20, readFileSync as readFileSync38, statSync as statSync17, unlinkSync as unlinkSync5, writeFileSync as writeFileSync21 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname23, join as join53 } from "path";
+function canonicalJson(x) {
+  const walk = (v) => {
+    if (Array.isArray(v))
+      return `[${v.map(walk).join(",")}]`;
+    if (v !== null && typeof v === "object") {
+      const o = v;
+      return `{${Object.keys(o).filter((k) => o[k] !== undefined).sort().map((k) => `${JSON.stringify(k)}:${walk(o[k])}`).join(",")}}`;
     }
-  }
-}
-function atomicWriteJson(target, data) {
-  durableWriteThenRename(target, `${JSON.stringify(data, null, 2)}
-`);
+    return JSON.stringify(v ?? null);
+  };
+  return walk(x).replace(/[\u0080-\uFFFF]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
 }
-var _tmpCounter = 0, _appendChains;
-var init_atomic = __esm(() => {
-  _appendChains = new Map;
-});
-
-// ../../loki-ts/src/util/pr_lessons.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname19, join as join45 } from "path";
-function loadLessons(repoDir) {
-  const p = lessonsPath(repoDir);
-  if (!existsSync25(p))
-    return [];
+function loadSigningKey(generate = true) {
   try {
-    const j = JSON.parse(readFileSync31(p, "utf-8"));
-    return Array.isArray(j.lessons) ? j.lessons : [];
+    const inline = process.env["LOKI_RECEIPT_SIGNING_KEY"]?.trim();
+    let pem = inline ?? "";
+    if (!inline) {
+      const given = process.env["LOKI_RECEIPT_SIGNING_KEY_FILE"]?.trim();
+      const file = given || join53(process.env["HOME"] || homedir8(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
+      try {
+        pem = readFileSync38(file);
+        if (!given) {
+          for (const [f, m] of [[file, 384], [dirname23(file), 448]])
+            if (statSync17(f).mode & 63)
+              chmodSync5(f, m);
+        }
+      } catch (e) {
+        if (e.code !== "ENOENT" || !generate)
+          return null;
+        mkdirSync20(dirname23(dirname23(file)), { recursive: true, mode: 448 });
+        mkdirSync20(dirname23(file), { recursive: true, mode: 448 });
+        const tmp = `${file}.${randomBytes3(6).toString("hex")}.tmp`;
+        writeFileSync21(tmp, generateKeyPairSync("ed25519").privateKey.export({ type: "pkcs8", format: "pem" }), { flag: "wx", mode: 384 });
+        try {
+          linkSync(tmp, file);
+        } catch (l) {
+          if (l.code !== "EEXIST")
+            throw l;
+        } finally {
+          unlinkSync5(tmp);
+        }
+        pem = readFileSync38(file);
+      }
+    }
+    const k = createPrivateKey(pem);
+    return k.asymmetricKeyType === "ed25519" ? k : null;
   } catch {
-    return [];
+    return null;
   }
 }
-function save(repoDir, lessons) {
-  const p = lessonsPath(repoDir);
-  mkdirSync13(dirname19(p), { recursive: true });
-  atomicWriteJson(p, { version: 2, lessons });
-}
-function recordRunVerdict(repoDir, runId, verdict) {
-  const lessons = loadLessons(repoDir);
-  let dirty = false;
-  for (const l of lessons)
-    for (const u of l.uses)
-      if (u.run_id === runId && u.verdict === null) {
-        u.verdict = verdict;
-        dirty = true;
-      }
-  if (dirty)
-    save(repoDir, lessons);
+function signReceipt(runId, hash) {
+  const key = loadSigningKey();
+  if (!key)
+    return { jwt: null, kid: null };
+  const kid = kidOf2(createPublicKey2(key));
+  const input = `${b64u(canonicalJson({ alg: "EdDSA", typ: "JWT", kid }))}.${b64u(canonicalJson({ job_id: runId, run_id: runId, receipt_sha256: hash, iat: Math.floor(Date.now() / 1000) }))}`;
+  return { jwt: `${input}.${b64u(sign(null, Buffer.from(input), key))}`, kid };
 }
-var lessonsPath = (repoDir) => join45(repoDir, ".loki", "memory", "semantic", "pr-lessons.json");
-var init_pr_lessons = __esm(() => {
-  init_atomic();
-});
+var RECEIPT_SIGNER_BASENAME = "receipt-ed25519.pem", b64u = (b) => Buffer.from(b).toString("base64url"), kidOf2 = (pub) => b64u(createHash11("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${pub.export({ format: "jwk" }).x}"}`).digest());
+var init_receipt_signer = () => {};
 
 // ../../loki-ts/src/features/visual_evidence.ts
 import { spawn as spawn7 } from "child_process";
-import { createHash as createHash10, randomBytes as randomBytes3 } from "crypto";
-import { existsSync as existsSync26, lstatSync as lstatSync10, mkdirSync as mkdirSync14, readdirSync as readdirSync14, readFileSync as readFileSync32, writeFileSync as writeFileSync15 } from "fs";
+import { createHash as createHash12, randomBytes as randomBytes4 } from "crypto";
+import { existsSync as existsSync32, lstatSync as lstatSync11, mkdirSync as mkdirSync21, readdirSync as readdirSync16, readFileSync as readFileSync39, writeFileSync as writeFileSync22 } from "fs";
 import { createServer } from "net";
-import { dirname as dirname20, isAbsolute as isAbsolute7, join as join46, normalize as normalize2, relative as relative8, sep as sep12 } from "path";
+import { dirname as dirname24, isAbsolute as isAbsolute8, join as join54, normalize as normalize2, relative as relative8, sep as sep12 } from "path";
 function routeFor(file) {
   let r = file.replace(/^(?:.*?\/)?(?:app|pages|src|public)\//, "").replace(/^(?:routes|pages)\//, "");
   r = r.replace(/\.(?:html|jsx|tsx|vue|svelte)$/, "").replace(/\/?(?:page|index|\+page)$/, "");
@@ -11561,7 +12797,7 @@ function hashScreens(runDir, rels) {
   const out2 = [];
   for (const rel of rels) {
     try {
-      out2.push({ path: rel, sha256: sha256File(join46(runDir, rel)) });
+      out2.push({ path: rel, sha256: sha256File(join54(runDir, rel)) });
     } catch {}
   }
   return out2;
@@ -11572,16 +12808,16 @@ function checkScreens(runDir, screens) {
   for (const s of screens) {
     if (typeof s?.path !== "string" || typeof s.sha256 !== "string")
       return "evidence_screens entry is malformed";
-    if (isAbsolute7(s.path) || normalize2(s.path).startsWith(".."))
+    if (isAbsolute8(s.path) || normalize2(s.path).startsWith(".."))
       return `evidence screenshot path escapes the evidence dir: ${s.path}`;
-    const file = join46(runDir, s.path);
+    const file = join54(runDir, s.path);
     let cur = runDir;
     for (const seg of normalize2(s.path).split(sep12)) {
-      cur = join46(cur, seg);
+      cur = join54(cur, seg);
       if (isSymlink(cur))
         return `evidence screenshot path is a symlink: ${s.path}`;
     }
-    if (!existsSync26(file))
+    if (!existsSync32(file))
       return `evidence screenshot is missing: ${s.path}`;
     if (!isRegularFile(file))
       return `evidence screenshot is not a regular file: ${s.path}`;
@@ -11624,11 +12860,11 @@ async function waitUp(url, ms, signal) {
 }
 function openapiPaths(repoDir) {
   for (const f of ["openapi.json", "openapi.yaml", "openapi.yml", "swagger.json"]) {
-    const p = join46(repoDir, f);
-    if (!existsSync26(p))
+    const p = join54(repoDir, f);
+    if (!existsSync32(p))
       continue;
     try {
-      const txt = readFileSync32(p, "utf8");
+      const txt = readFileSync39(p, "utf8");
       const paths = f.endsWith(".json") ? Object.keys(JSON.parse(txt).paths ?? {}) : [...txt.matchAll(/^ {2}(\/[^\s:]*):\s*$/gm)].map((m) => m[1]);
       return paths.filter((x) => !x.includes("{")).slice(0, 10);
     } catch {
@@ -11642,24 +12878,24 @@ async function recordE2eMedia(repoDir, runDir, relDir, base, routes, ms, signal)
   if (!pw || !pkg)
     return { rels: [], skipped: "playwright e2e video and trace skipped: @playwright/test is not installed in the repo" };
   try {
-    const dir = join46(runDir, relDir, "e2e");
-    mkdirSync14(dir, { recursive: true });
-    writeFileSync15(join46(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
-    writeFileSync15(join46(dir, "playwright.config.cjs"), `module.exports = { testDir: ".", testMatch: "walk.spec.cjs", outputDir: "./out", reporter: "null", use: { video: "on", trace: "on" } };
+    const dir = join54(runDir, relDir, "e2e");
+    mkdirSync21(dir, { recursive: true });
+    writeFileSync22(join54(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
+    writeFileSync22(join54(dir, "playwright.config.cjs"), `module.exports = { testDir: ".", testMatch: "walk.spec.cjs", outputDir: "./out", reporter: "null", use: { video: "on", trace: "on" } };
 `);
-    if (!await shoot(pw, ["test", "--config", join46(dir, "playwright.config.cjs")], repoDir, ms, signal))
+    if (!await shoot(pw, ["test", "--config", join54(dir, "playwright.config.cjs")], repoDir, ms, signal))
       return { rels: [], skipped: "playwright e2e video and trace skipped: the run failed or timed out" };
     const rels = [];
     const walk = (d) => {
-      for (const e of readdirSync14(d, { withFileTypes: true })) {
-        const full = join46(d, e.name);
+      for (const e of readdirSync16(d, { withFileTypes: true })) {
+        const full = join54(d, e.name);
         if (e.isDirectory())
           walk(full);
         else if (e.isFile() && /\.(webm|zip)$/.test(e.name))
-          rels.push(join46(relDir, "e2e", relative8(dir, full)));
+          rels.push(join54(relDir, "e2e", relative8(dir, full)));
       }
     };
-    walk(join46(dir, "out"));
+    walk(join54(dir, "out"));
     return rels.length > 0 ? { rels, skipped: null } : { rels, skipped: "playwright e2e video and trace skipped: no video or trace was produced" };
   } catch (e) {
     return { rels: [], skipped: `playwright e2e video and trace skipped: ${String(e?.message ?? e).slice(0, 120)}` };
@@ -11728,13 +12964,13 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
     if (!visualEvidenceEnabled(opts.env))
       return skip("LOKI_VISUAL_EVIDENCE is 0");
     const api = loadProjectApi(repoDir), boot = isMultiRoot(api) ? api.uiBoot() : null;
-    const appDir = boot ? join46(repoDir, boot.boot.cwd) : repoDir;
-    const pkgPath = join46(appDir, "package.json");
+    const appDir = boot ? join54(repoDir, boot.boot.cwd) : repoDir;
+    const pkgPath = join54(appDir, "package.json");
     let script = null;
     if (!boot) {
-      if (!existsSync26(pkgPath))
+      if (!existsSync32(pkgPath))
         return skip("no package.json");
-      script = pickScript(JSON.parse(readFileSync32(pkgPath, "utf8")));
+      script = pickScript(JSON.parse(readFileSync39(pkgPath, "utf8")));
       if (!script)
         return skip("no dev, preview or start script");
     }
@@ -11761,20 +12997,20 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
     }
     if (!await waitUp(base, left(), signal))
       return skip(aborted() ? "aborted" : `${script} server did not answer within ${Math.round(budget / 1000)}s`);
-    const evRoot = join46(runDir, "evidence");
+    const evRoot = join54(runDir, "evidence");
     if (isSymlink(evRoot))
       return skip("evidence dir is a symlink");
-    mkdirSync14(evRoot, { recursive: true });
+    mkdirSync21(evRoot, { recursive: true });
     if (pages.length > 0) {
-      const rel0 = join46("evidence", randomBytes3(6).toString("hex"));
-      mkdirSync14(join46(runDir, rel0));
+      const rel0 = join54("evidence", randomBytes4(6).toString("hex"));
+      mkdirSync21(join54(runDir, rel0));
       const rels = [];
       for (const route of [...new Set(pages.map(routeFor))].slice(0, opts.maxRoutes ?? MAX_ROUTES)) {
         if (aborted() || left() <= 0)
           break;
-        const rel = join46(rel0, `${screenName(route)}.png`);
-        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join46(runDir, rel)], appDir, left(), signal);
-        if (ok && !aborted() && !isSymlink(join46(runDir, rel)) && existsSync26(join46(runDir, rel)))
+        const rel = join54(rel0, `${screenName(route)}.png`);
+        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join54(runDir, rel)], appDir, left(), signal);
+        if (ok && !aborted() && !isSymlink(join54(runDir, rel)) && existsSync32(join54(runDir, rel)))
           rels.push(rel);
       }
       if (aborted())
@@ -11799,9 +13035,9 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
     }
     if (aborted())
       return skip("aborted");
-    const hdir = join46(evRoot, randomBytes3(6).toString("hex"));
-    mkdirSync14(hdir);
-    writeFileSync15(join46(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
+    const hdir = join54(evRoot, randomBytes4(6).toString("hex"));
+    mkdirSync21(hdir);
+    writeFileSync22(join54(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
 `);
     return { screens: [], http: true, skipped: null };
   } catch (e) {
@@ -11824,27 +13060,27 @@ async function sealEvidence(repoDir, runDir, o, notProven, signal, emit) {
   return ev.screens.length > 0 ? { evidence_screens: ev.screens } : {};
 }
 function receiptScreensProblem(receiptPath, receipt) {
-  return receipt["evidence_screens"] === undefined ? null : checkScreens(dirname20(receiptPath), receipt["evidence_screens"]);
+  return receipt["evidence_screens"] === undefined ? null : checkScreens(dirname24(receiptPath), receipt["evidence_screens"]);
 }
-var visualEvidenceEnabled = (env = process.env) => env["LOKI_VISUAL_EVIDENCE"] !== "0", PAGE_RE, isPageFile = (p) => PAGE_RE.test(p), screenName = (route) => (route === "/" ? "index" : route.slice(1).replace(/[^A-Za-z0-9._-]+/g, "_")) || "index", sha256File = (p) => createHash10("sha256").update(readFileSync32(p)).digest("hex"), playwrightBin = (repoDir) => {
-  const bin = join46(repoDir, "node_modules", ".bin", "playwright");
-  return existsSync26(bin) ? bin : null;
+var visualEvidenceEnabled = (env = process.env) => env["LOKI_VISUAL_EVIDENCE"] !== "0", PAGE_RE, isPageFile = (p) => PAGE_RE.test(p), screenName = (route) => (route === "/" ? "index" : route.slice(1).replace(/[^A-Za-z0-9._-]+/g, "_")) || "index", sha256File = (p) => createHash12("sha256").update(readFileSync39(p)).digest("hex"), playwrightBin = (repoDir) => {
+  const bin = join54(repoDir, "node_modules", ".bin", "playwright");
+  return existsSync32(bin) ? bin : null;
 }, playwrightTestPkg = (repoDir) => {
-  const d = join46(repoDir, "node_modules", "@playwright", "test");
-  return existsSync26(join46(d, "package.json")) ? d : null;
+  const d = join54(repoDir, "node_modules", "@playwright", "test");
+  return existsSync32(join54(d, "package.json")) ? d : null;
 }, e2eSpecSource = (pkgDir, base, routes) => `const { test } = require(${JSON.stringify(pkgDir)});
 test("loki e2e walkthrough", async ({ page }) => {
   for (const r of ${JSON.stringify(routes)}) { await page.goto(${JSON.stringify(base)} + r); await page.waitForLoadState("load"); }
 });
 `, DEFAULT_BUDGET_MS = 25000, MAX_ROUTES = 5, isSymlink = (p) => {
   try {
-    return lstatSync10(p).isSymbolicLink();
+    return lstatSync11(p).isSymbolicLink();
   } catch {
     return false;
   }
 }, isRegularFile = (p) => {
   try {
-    return lstatSync10(p).isFile();
+    return lstatSync11(p).isFile();
   } catch {
     return false;
   }
@@ -11862,14 +13098,14 @@ var init_visual_evidence = __esm(() => {
 });
 
 // ../../loki-ts/src/council/role_agents.ts
-import { existsSync as existsSync27, readdirSync as readdirSync15, readFileSync as readFileSync33 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join47 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync17, readFileSync as readFileSync40 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join55 } from "path";
 function agentDirs(repoDir, env = process.env) {
-  return [env["LOKI_AGENTS_PROJECT_DIR"] || join47(repoDir, ".loki", "agents"), env["LOKI_AGENTS_USER_DIR"] || join47(env["XDG_CONFIG_HOME"] || join47(homedir8(), ".config"), "loki", "agents")];
+  return [env["LOKI_AGENTS_PROJECT_DIR"] || join55(repoDir, ".loki", "agents"), env["LOKI_AGENTS_USER_DIR"] || join55(env["XDG_CONFIG_HOME"] || join55(homedir9(), ".config"), "loki", "agents")];
 }
 function parseAgent(file, stem2) {
-  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(readFileSync33(file, "utf8"));
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(readFileSync40(file, "utf8"));
   if (!m)
     return null;
   const body = m[2].trim();
@@ -11883,18 +13119,18 @@ function parseAgent(file, stem2) {
 }
 function loadRoleAgent(repoDir, role, env = process.env) {
   for (const d of agentDirs(repoDir, env)) {
-    if (!existsSync27(d))
+    if (!existsSync33(d))
       continue;
     let names;
     try {
-      names = readdirSync15(d).filter((n2) => n2.endsWith(".md") && !n2.startsWith(".")).sort();
+      names = readdirSync17(d).filter((n2) => n2.endsWith(".md") && !n2.startsWith(".")).sort();
     } catch {
       continue;
     }
     const ordered = [...names.filter((n2) => n2 === `${role}.md`), ...names.filter((n2) => n2 !== `${role}.md`)];
     for (const n2 of ordered) {
       try {
-        const a = parseAgent(join47(d, n2), n2.slice(0, -3));
+        const a = parseAgent(join55(d, n2), n2.slice(0, -3));
         if (a && a.role === role)
           return a;
       } catch {}
@@ -11910,83 +13146,12 @@ var init_role_agents = __esm(() => {
   ROLES = ["council", "reviewer"];
 });
 
-// ../../loki-ts/src/util/shell.ts
-async function readStreamCapped(stream, maxBytes = MAX_STDOUT_BYTES) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let out2 = "";
-  let total = 0;
-  try {
-    while (total < maxBytes) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (!value)
-        continue;
-      total += value.byteLength;
-      if (total > maxBytes) {
-        const keep = value.byteLength - (total - maxBytes);
-        out2 += decoder.decode(value.subarray(0, keep), { stream: true });
-        break;
-      }
-      out2 += decoder.decode(value, { stream: true });
-    }
-    out2 += decoder.decode();
-  } finally {
-    try {
-      await reader.cancel();
-    } catch {}
-    reader.releaseLock();
-  }
-  return out2;
-}
-async function run(argv, opts = {}) {
-  const proc = Bun.spawn({
-    cmd: [...argv],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: opts.env ? { ...process.env, ...opts.env } : process.env,
-    cwd: opts.cwd
-  });
-  let timer;
-  let killTimer;
-  if (opts.timeoutMs && opts.timeoutMs > 0) {
-    timer = setTimeout(() => {
-      try {
-        proc.kill("SIGTERM");
-      } catch {}
-      killTimer = setTimeout(() => {
-        try {
-          proc.kill("SIGKILL");
-        } catch {}
-      }, 2000);
-    }, opts.timeoutMs);
-  }
-  try {
-    const [stdout, stderr, exitCode] = await Promise.all([
-      readStreamCapped(proc.stdout),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    return { stdout, stderr, exitCode };
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-    if (killTimer)
-      clearTimeout(killTimer);
-  }
-}
-var MAX_STDOUT_BYTES;
-var init_shell = __esm(() => {
-  MAX_STDOUT_BYTES = 16 * 1024 * 1024;
-});
-
 // ../../loki-ts/src/engine10/stages/xreview.ts
-import { existsSync as existsSync28, readFileSync as readFileSync34 } from "fs";
-import { join as join48 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync41 } from "fs";
+import { join as join56 } from "path";
 function minVerdict(verdict, review) {
   const ceiling = review?.level === "block" ? "PARTIAL" : verdict;
-  return RANK2[ceiling] < RANK2[verdict] ? ceiling : verdict;
+  return RANK3[ceiling] < RANK3[verdict] ? ceiling : verdict;
 }
 function explicitReview(repoDir, env) {
   const flag = xvendorDefault(env);
@@ -11996,11 +13161,11 @@ function explicitReview(repoDir, env) {
   if (flag && isOff(ev))
     return "off";
   for (const f of ["loki.yaml", "loki.yml"]) {
-    const p = join48(repoDir, f);
-    if (!existsSync28(p))
+    const p = join56(repoDir, f);
+    if (!existsSync34(p))
       continue;
     try {
-      const m = /^review:[ \t]*["']?([A-Za-z]+)["']?[ \t]*(?:#.*)?$/m.exec(readFileSync34(p, "utf8"));
+      const m = /^review:[ \t]*["']?([A-Za-z]+)["']?[ \t]*(?:#.*)?$/m.exec(readFileSync41(p, "utf8"));
       const v = asProvider(m?.[1]);
       if (v)
         return v;
@@ -12078,7 +13243,7 @@ Review ONLY the diff below. Do not modify files.` : "You are an independent code
     return { provider: p, level: "not_run", notes: [`cross-review not run: ${p} CLI unavailable`] };
   }
 }
-var RANK2, TIMEOUT_MS = 300000, MAX_DIFF = 60000, MAX_NOTES = 5, asProvider = (v) => {
+var RANK3, TIMEOUT_MS = 300000, MAX_DIFF = 60000, MAX_NOTES = 5, asProvider = (v) => {
   const s = v?.trim().toLowerCase();
   return s === "codex" || s === "claude" ? s : null;
 }, isOff = (v) => /^(off|none|false|0)$/i.test(v?.trim() ?? ""), xvendorDefault = (env = process.env) => /^(1|true|yes|on)$/i.test(env["LOKI_XVENDOR_DEFAULT"]?.trim() ?? ""), reviewCli = (p, env = process.env) => env[`LOKI_${p.toUpperCase()}_CLI`]?.trim() || p, clean3 = (s) => s.replace(/[\x00-\x1f\x7f`]+/g, " ").trim().slice(0, 300);
@@ -12086,107 +13251,7 @@ var init_xreview = __esm(() => {
   init_role_agents();
   init_shell();
   init_safe_git();
-  RANK2 = { FAILED: 0, SPEC_CONFLICT: 0, PARTIAL: 1, ALREADY_SATISFIED: 2, VERIFIED: 2 };
-});
-
-// ../../loki-ts/src/runner/router/route_record.ts
-import { existsSync as existsSync29, lstatSync as lstatSync11, mkdirSync as mkdirSync15, readFileSync as readFileSync35, writeFileSync as writeFileSync16 } from "fs";
-import { join as join49 } from "path";
-function loadRouteRecord(runDir) {
-  try {
-    const p = join49(runDir, ROUTE_RECORD_FILE);
-    if (!existsSync29(p) || !lstatSync11(p).isFile())
-      return;
-    const v = JSON.parse(readFileSync35(p, "utf8"));
-    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
-  } catch {
-    return;
-  }
-}
-var ROUTE_RECORD_FILE = "route.json";
-var init_route_record = () => {};
-
-// ../../loki-ts/src/runner/router/history_store.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync16, readFileSync as readFileSync36, renameSync as renameSync6, rmSync as rmSync12, writeFileSync as writeFileSync17 } from "fs";
-import { resolve as resolve11 } from "path";
-function validRun(v) {
-  if (typeof v !== "object" || v === null)
-    return false;
-  const r = v;
-  return typeof r["shape"] === "string" && typeof r["executor"] === "string" && EXECUTORS.includes(r["executor"]) && typeof r["verdict"] === "string" && VERDICTS.includes(r["verdict"]) && (r["owner"] === null || typeof r["owner"] === "string" && OWNERS.includes(r["owner"])) && typeof r["escalated"] === "boolean" && typeof r["usd"] === "number" && Number.isFinite(r["usd"]) && typeof r["wallS"] === "number" && Number.isFinite(r["wallS"]);
-}
-function historyPath(key, cacheRoot) {
-  return resolve11(repoCacheDir(key, cacheRoot), HISTORY_FILE);
-}
-function readRunHistory(key, cacheRoot) {
-  const path = historyPath(key, cacheRoot);
-  if (!existsSync30(path))
-    return [];
-  try {
-    const parsed = JSON.parse(readFileSync36(path, "utf8"));
-    const runs2 = parsed?.runs;
-    return Array.isArray(runs2) ? runs2.filter(validRun) : [];
-  } catch {
-    return [];
-  }
-}
-function appendRunOutcome(key, outcome, cacheRoot) {
-  try {
-    const runs2 = [...readRunHistory(key, cacheRoot), outcome].slice(-HISTORY_CAP);
-    mkdirSync16(repoCacheDir(key, cacheRoot), { recursive: true });
-    const target = historyPath(key, cacheRoot);
-    const tmp = `${target}.${process.pid}.tmp`;
-    try {
-      writeFileSync17(tmp, JSON.stringify({ runs: runs2 }));
-      renameSync6(tmp, target);
-    } catch (e) {
-      rmSync12(tmp, { force: true, recursive: false });
-      throw e;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-var HISTORY_FILE = "router_history.json", HISTORY_CAP = 200, WALL_KIND = "total-v1", EXECUTORS, VERDICTS, OWNERS;
-var init_history_store = __esm(() => {
-  init_cache();
-  EXECUTORS = ["haiku", "sonnet"];
-  VERDICTS = ["pass", "fail", "error", "not_proven"];
-  OWNERS = ["code", "harness", "env", "provider"];
-});
-
-// ../../loki-ts/src/runner/router/history.ts
-import { dirname as dirname21, join as join50, resolve as resolve12 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function shapeKey(model) {
-  if (!model || model.status !== "ok")
-    return null;
-  const runners = new Set(model.packages.map((p) => (p.runner ?? "").trim().toLowerCase() || "none"));
-  return `${model.workspaceKind}:${[...runners].sort().join("+")}`;
-}
-function shapeKeyForRepo(repoDir) {
-  try {
-    const dirs = shallowDirs(repoDir);
-    const committed = loadCommitted(repoDir);
-    if (committed)
-      return shapeKey({ ...committed.model, key: computeKey(repoDir, committed.model.fingerprintFiles, dirs, committed.hash) });
-    const cached = loadCached(repoDir);
-    if (!cached || computeKey(repoDir, cached.fingerprintFiles, dirs) !== cached.key)
-      return null;
-    return shapeKey(cached);
-  } catch {
-    return null;
-  }
-}
-var SHAPE_DEFAULTS_FILE;
-var init_history = __esm(() => {
-  init_schema();
-  init_history_store();
-  init_discover2();
-  init_gather();
-  init_history_store();
-  SHAPE_DEFAULTS_FILE = resolve12(dirname21(fileURLToPath3(import.meta.url)), "..", "..", "..", "data", "router-shape-defaults.json");
+  RANK3 = { FAILED: 0, SPEC_CONFLICT: 0, PARTIAL: 1, ALREADY_SATISFIED: 2, VERIFIED: 2 };
 });
 
 // ../../loki-ts/src/util/engine_origin.ts
@@ -12235,9 +13300,9 @@ var init_cost_preview = __esm(() => {
 });
 
 // ../../loki-ts/src/features/contract.ts
-import { existsSync as existsSync31, lstatSync as lstatSync12, mkdirSync as mkdirSync17, readFileSync as readFileSync37, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname22, join as join51 } from "path";
-import { createHash as createHash11 } from "crypto";
+import { existsSync as existsSync35, lstatSync as lstatSync12, mkdirSync as mkdirSync22, readFileSync as readFileSync42, rmSync as rmSync14, writeFileSync as writeFileSync23 } from "fs";
+import { dirname as dirname25, join as join57 } from "path";
+import { createHash as createHash13 } from "crypto";
 function contractEnabled(env = process.env) {
   return env["LOKI_CONTRACT"] !== "0";
 }
@@ -12268,7 +13333,7 @@ function untracedLines(trace) {
   return trace.criteria.filter((c) => c.status === "no_match").map((c) => `contract ${sanitizeCriterion(c.id)} untraced (no keyword match in changed files): ${sanitizeCriterion(c.text)}`);
 }
 function contractPath(repoDir) {
-  return join51(repoDir, ".loki", "contract.json");
+  return join57(repoDir, ".loki", "contract.json");
 }
 function readContract(repoDir) {
   const p = contractPath(repoDir);
@@ -12284,11 +13349,11 @@ function readContract(repoDir) {
     return { contract: null, notes: ["contract unreadable: too large"], sha256: null };
   let raw2;
   try {
-    raw2 = readFileSync37(p);
+    raw2 = readFileSync42(p);
   } catch {
     return { contract: null, notes: ["contract unreadable: read failed"], sha256: null };
   }
-  const sha2563 = createHash11("sha256").update(raw2).digest("hex");
+  const sha2563 = createHash13("sha256").update(raw2).digest("hex");
   let j;
   try {
     j = JSON.parse(raw2.toString("utf8"));
@@ -12345,16 +13410,21 @@ function sealContract(repoDir, body, rawDiff, checks, env = process.env, snap) {
     return [`contract trace failed: ${sanitizeCriterion(e instanceof Error ? e.message : String(e))}`];
   }
 }
-var MAX_CRITERIA = 50, MAX_TEXT = 500, STOP2, MAX_CONTRACT_BYTES;
+var MAX_CRITERIA = 50, MAX_TEXT = 500, STOP2, MAX_CONTRACT_BYTES, REQ_MAP_REL, REQ_STOP;
 var init_contract = __esm(() => {
+  init_atomic();
+  init_spec_file();
+  init_paths();
   init_safe_git();
   STOP2 = new Set(["the", "and", "for", "with", "that", "this", "must", "should", "shall", "when", "then", "are", "was", "all", "any", "can", "not", "has", "have", "from", "into", "each", "user", "users"]);
   MAX_CONTRACT_BYTES = 1024 * 1024;
+  REQ_MAP_REL = join57(".loki", "state", "requirements-map.json");
+  REQ_STOP = new Set(["with", "that", "this", "from", "have", "will", "should", "must", "when", "then", "into", "each", "every", "user", "users", "page", "able", "allow", "support", "ensure", "using", "their", "there", "which", "shall"]);
 });
 
 // ../../loki-ts/src/supply/supply_guard.ts
-import { existsSync as existsSync32, readFileSync as readFileSync38, statSync as statSync16 } from "fs";
-import { basename as basename17, join as join52 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync43, statSync as statSync18 } from "fs";
+import { basename as basename19, join as join58 } from "path";
 function supplyEnabled(env) {
   return env["LOKI_SUPPLY_GUARD"] !== "0";
 }
@@ -12366,16 +13436,16 @@ function supplyVerdict(verdict, r) {
   return r.blocked && verdict === "VERIFIED" ? "FAILED" : verdict;
 }
 function isManifestPath(path) {
-  return MANIFESTS.test(basename17(path));
+  return MANIFESTS.test(basename19(path));
 }
 function readDeclared(repoDir) {
-  const p = join52(repoDir, ".loki", DECLARED_FILE);
-  if (!existsSync32(p))
+  const p = join58(repoDir, ".loki", DECLARED_FILE);
+  if (!existsSync36(p))
     return { deps: [], problem: null };
   try {
-    if (statSync16(p).size > MAX_FILE_BYTES)
+    if (statSync18(p).size > MAX_FILE_BYTES)
       return { deps: [], problem: "declaration file too large" };
-    const j = JSON.parse(readFileSync38(p, "utf8"));
+    const j = JSON.parse(readFileSync43(p, "utf8"));
     if (!Array.isArray(j))
       return { deps: [], problem: "declaration is not a JSON array" };
     const deps = [];
@@ -12395,11 +13465,11 @@ function readDeclared(repoDir) {
   }
 }
 function readAllowlist(repoDir) {
-  const p = join52(repoDir, ".loki", "supply-allowlist");
-  if (!existsSync32(p))
+  const p = join58(repoDir, ".loki", "supply-allowlist");
+  if (!existsSync36(p))
     return new Set;
   try {
-    return new Set(readFileSync38(p, "utf8").split(`
+    return new Set(readFileSync43(p, "utf8").split(`
 `).map((l) => l.replace(/#.*$/, "").trim()).filter(Boolean));
   } catch {
     return new Set;
@@ -12440,7 +13510,7 @@ function userConfigPrivate(eco, repoDir, env, goEnv = {}, name = "") {
   if (eco === "npm") {
     if (privateUrlList([env["npm_config_registry"] ?? "", env["NPM_CONFIG_REGISTRY"] ?? ""]))
       return true;
-    return files(join52(repoDir, ".npmrc"), home ? join52(home, ".npmrc") : "").some((t) => t.split(`
+    return files(join58(repoDir, ".npmrc"), home ? join58(home, ".npmrc") : "").some((t) => t.split(`
 `).some((l) => {
       const m = /^\s*(?:(@[^:\s]+):)?registry\s*=\s*(\S+)/.exec(l);
       return !!m && privateUrl(m[2]) && (m[1] === undefined || name.startsWith(`${m[1]}/`));
@@ -12449,7 +13519,7 @@ function userConfigPrivate(eco, repoDir, env, goEnv = {}, name = "") {
   if (eco === "pypi") {
     if (privateUrlList([env["PIP_INDEX_URL"] ?? "", env["PIP_EXTRA_INDEX_URL"] ?? ""]))
       return true;
-    const cfg = [env["PIP_CONFIG_FILE"] ?? "", home ? join52(home, ".config", "pip", "pip.conf") : "", home ? join52(home, ".pip", "pip.conf") : "", join52(repoDir, "pip.conf")];
+    const cfg = [env["PIP_CONFIG_FILE"] ?? "", home ? join58(home, ".config", "pip", "pip.conf") : "", home ? join58(home, ".pip", "pip.conf") : "", join58(repoDir, "pip.conf")];
     return files(...cfg).some((t) => t.split(`
 `).some((l) => {
       const m = /^\s*(?:extra-)?index-url\s*[=:]\s*(.+)$/.exec(l);
@@ -12459,7 +13529,7 @@ function userConfigPrivate(eco, repoDir, env, goEnv = {}, name = "") {
   if (eco === "cargo") {
     if (Object.keys(env).some((k) => /^CARGO_REGISTRIES_.+_INDEX$/.test(k) || /^CARGO_SOURCE_/.test(k)))
       return true;
-    return files(join52(repoDir, ".cargo", "config.toml"), join52(repoDir, ".cargo", "config"), home ? join52(home, ".cargo", "config.toml") : "", home ? join52(home, ".cargo", "config") : "").some((t) => /^\s*\[(registries\.|source\.)/m.test(t) || /replace-with\s*=/.test(t));
+    return files(join58(repoDir, ".cargo", "config.toml"), join58(repoDir, ".cargo", "config"), home ? join58(home, ".cargo", "config.toml") : "", home ? join58(home, ".cargo", "config") : "").some((t) => /^\s*\[(registries\.|source\.)/m.test(t) || /replace-with\s*=/.test(t));
   }
   if (eco === "go") {
     const gp = goEnv["GOPROXY"] ?? env["GOPROXY"] ?? "";
@@ -12582,7 +13652,7 @@ var MIN_AGE_DAYS = 7, DECLARED_FILE = "supply-declared.json", MAX_CHECKED = 50,
   }
 }, PUBLIC_HOSTS, hostOf = (u) => u.trim().toLowerCase().replace(/^[a-z][a-z0-9+.-]*:\/\//, "").replace(/^www\./, "").split(/[/?#\s]/)[0].replace(/^[^@]*@/, "").replace(/:\d+$/, ""), privateUrl = (u) => /[a-z0-9]/i.test(u) && !PUBLIC_HOSTS.has(hostOf(u)), readSmall = (p) => {
   try {
-    return statSync16(p).size <= MAX_FILE_BYTES ? readFileSync38(p, "utf8") : "";
+    return statSync18(p).size <= MAX_FILE_BYTES ? readFileSync43(p, "utf8") : "";
   } catch {
     return "";
   }
@@ -12597,77 +13667,18 @@ var init_supply_guard = __esm(() => {
 });
 
 // ../../loki-ts/src/engine10/stages/seal.ts
-import { createHash as createHash12, randomBytes as randomBytes4, createPrivateKey, createPublicKey as createPublicKey2, generateKeyPairSync, sign } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync33, readdirSync as readdirSync16, linkSync, mkdirSync as mkdirSync18, readFileSync as readFileSync39, statSync as statSync17, unlinkSync as unlinkSync5, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir9 } from "os";
-import { basename as basename18, dirname as dirname23, isAbsolute as isAbsolute8, join as join53, relative as relative9 } from "path";
+import { createHash as createHash14 } from "crypto";
+import { existsSync as existsSync37, readdirSync as readdirSync18, mkdirSync as mkdirSync23, readFileSync as readFileSync44, writeFileSync as writeFileSync24 } from "fs";
+import { basename as basename20, isAbsolute as isAbsolute9, join as join59, relative as relative9 } from "path";
 function sanitizeReason(s) {
   const collapsed = s.replace(/[\x00-\x1f\x7f]+/g, " ").trim();
   const capped = collapsed.length > 500 ? `${collapsed.slice(0, 500)}...` : collapsed;
   return capped.replace(/`/g, "'");
 }
-function canonicalJson(x) {
-  const walk = (v) => {
-    if (Array.isArray(v))
-      return `[${v.map(walk).join(",")}]`;
-    if (v !== null && typeof v === "object") {
-      const o = v;
-      return `{${Object.keys(o).filter((k) => o[k] !== undefined).sort().map((k) => `${JSON.stringify(k)}:${walk(o[k])}`).join(",")}}`;
-    }
-    return JSON.stringify(v ?? null);
-  };
-  return walk(x).replace(/[\u0080-\uFFFF]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
-}
 function receiptSha256(r) {
   const { verification: _v, receipt_sha256: _h, ...body } = r;
   return sha2562(canonicalJson(body));
 }
-function loadSigningKey(generate = true) {
-  try {
-    const inline = process.env["LOKI_RECEIPT_SIGNING_KEY"]?.trim();
-    let pem = inline ?? "";
-    if (!inline) {
-      const given = process.env["LOKI_RECEIPT_SIGNING_KEY_FILE"]?.trim();
-      const file = given || join53(process.env["HOME"] || homedir9(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
-      try {
-        pem = readFileSync39(file);
-        if (!given) {
-          for (const [f, m] of [[file, 384], [dirname23(file), 448]])
-            if (statSync17(f).mode & 63)
-              chmodSync5(f, m);
-        }
-      } catch (e) {
-        if (e.code !== "ENOENT" || !generate)
-          return null;
-        mkdirSync18(dirname23(dirname23(file)), { recursive: true, mode: 448 });
-        mkdirSync18(dirname23(file), { recursive: true, mode: 448 });
-        const tmp = `${file}.${randomBytes4(6).toString("hex")}.tmp`;
-        writeFileSync19(tmp, generateKeyPairSync("ed25519").privateKey.export({ type: "pkcs8", format: "pem" }), { flag: "wx", mode: 384 });
-        try {
-          linkSync(tmp, file);
-        } catch (l) {
-          if (l.code !== "EEXIST")
-            throw l;
-        } finally {
-          unlinkSync5(tmp);
-        }
-        pem = readFileSync39(file);
-      }
-    }
-    const k = createPrivateKey(pem);
-    return k.asymmetricKeyType === "ed25519" ? k : null;
-  } catch {
-    return null;
-  }
-}
-function signReceipt(runId, hash) {
-  const key = loadSigningKey();
-  if (!key)
-    return { jwt: null, kid: null };
-  const kid = kidOf2(createPublicKey2(key));
-  const input = `${b64u(canonicalJson({ alg: "EdDSA", typ: "JWT", kid }))}.${b64u(canonicalJson({ job_id: runId, run_id: runId, receipt_sha256: hash, iat: Math.floor(Date.now() / 1000) }))}`;
-  return { jwt: `${input}.${b64u(sign(null, Buffer.from(input), key))}`, kid };
-}
 async function git3(ctx, args, keep = {}) {
   const r = await safeGitRun(ctx.repoDir, args, { timeoutMs: 20000, ...keep });
   return { out: r.stdout, code: r.exitCode };
@@ -12732,9 +13743,9 @@ function renderReceiptMd(r) {
   ].join(`
 `);
 }
-var DEEP_NOT_PROVEN, SIGNING_UNAVAILABLE = "receipt signing unavailable (no usable signing key: invalid key or unwritable ~/.loki/keys)", EXCLUDE_LOKI = ":(exclude).loki", sha2562 = (s) => createHash12("sha256").update(s).digest("hex"), str3 = (v) => typeof v === "string" && v !== "" ? v : null, strs2 = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [], b64u = (b) => Buffer.from(b).toString("base64url"), kidOf2 = (pub) => b64u(createHash12("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${pub.export({ format: "jwk" }).x}"}`).digest()), receiptRel = (ctx) => {
-  const r = relative9(ctx.repoDir, join53(ctx.runDir, "receipt.json"));
-  return r.startsWith("..") || isAbsolute8(r) ? `.loki/runs/${ctx.runId}/receipt.json` : r;
+var DEEP_NOT_PROVEN, SIGNING_UNAVAILABLE = "receipt signing unavailable (no usable signing key: invalid key or unwritable ~/.loki/keys)", EXCLUDE_LOKI = ":(exclude).loki", sha2562 = (s) => createHash14("sha256").update(s).digest("hex"), str3 = (v) => typeof v === "string" && v !== "" ? v : null, strs2 = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [], receiptRel = (ctx) => {
+  const r = relative9(ctx.repoDir, join59(ctx.runDir, "receipt.json"));
+  return r.startsWith("..") || isAbsolute9(r) ? `.loki/runs/${ctx.runId}/receipt.json` : r;
 }, commitStage, sealStage;
 var init_seal = __esm(() => {
   init_spec_file();
@@ -12745,6 +13756,7 @@ var init_seal = __esm(() => {
   init_discard();
   init_commit_filter();
   init_scope2();
+  init_receipt_signer();
   init_pr_lessons();
   init_visual_evidence();
   init_testmap();
@@ -12835,8 +13847,8 @@ var init_seal = __esm(() => {
         notProven.add(`Wall test not executed: ${wallNotRun} file(s), no reason recorded`);
       if (wallNotRun > 0) {
         try {
-          const kept = new Set((Array.isArray(o.wall?.files) ? o.wall.files : []).map((f) => basename18(String(f.path))));
-          for (const n2 of readdirSync16(join53(ctx.runDir, "wall")).sort())
+          const kept = new Set((Array.isArray(o.wall?.files) ? o.wall.files : []).map((f) => basename20(String(f.path))));
+          for (const n2 of readdirSync18(join59(ctx.runDir, "wall")).sort())
             if (!kept.has(n2))
               notProven.add(`wall test discarded: ${n2} (not_run)`);
         } catch {}
@@ -12875,6 +13887,8 @@ var init_seal = __esm(() => {
         notProven.add(n2);
       for (const id of strs2(o.verify?.pre_red))
         notProven.add(`pre red: ${id}`);
+      if (typeof o.verify?.baseline_line === "string" && strs2(o.verify?.pre_red).length)
+        notProven.add(o.verify.baseline_line);
       for (const t of strs2(o.implement?.tests_reverted))
         notProven.add(`reverted test edit: ${t}`);
       if (ctx.provider !== "claude")
@@ -12895,19 +13909,19 @@ var init_seal = __esm(() => {
       for (const [s, d] of Object.entries(o))
         if (typeof d?.duration_s === "number")
           stages[s] = d.duration_s;
-      const T = hooks.time, time = T ? T.build(ctx, stages, T.firstEventMs(join53(ctx.runDir, "events.jsonl"))) : { wall_s: Object.values(stages).reduce((a, b) => a + (b ?? 0), 0), stages }, totalS = T?.reconciled(time) ?? null;
+      const T = hooks.time, time = T ? T.build(ctx, stages, T.firstEventMs(join59(ctx.runDir, "events.jsonl"))) : { wall_s: Object.values(stages).reduce((a, b) => a + (b ?? 0), 0), stages }, totalS = T?.reconciled(time) ?? null;
       const iterIds = Object.values(o).flatMap((d) => [...strs2(d?.iteration_ids), ...strs2([d?.iteration_id])]);
       if (iterIds.length === 0)
         notProven.add("cost not measured (no iteration ids recorded)");
       const cost = ctx.cost.read(ctx.repoDir, iterIds);
       if (cost.unmetered)
         notProven.add("cost unmetered (CLI invoker; recorded as 0)");
-      const eventsPath = join53(ctx.runDir, "events.jsonl");
+      const eventsPath = join59(ctx.runDir, "events.jsonl");
       const wallFiles = Array.isArray(o.wall?.files) ? o.wall.files : [];
       const wallPassed = typeof o.verify?.wall_passed === "boolean" ? o.verify.wall_passed : null;
       if (wallFiles.length > 0 && wallPassed === null)
         notProven.add("wall result not recorded by verify");
-      const routeBlock = buildRouteBlock(process.env, ctx.provider, o.implement?.route ?? o.plan?.route_record ?? (routerEnabled(process.env) ? loadRouteRecord(ctx.runDir) : undefined), cost.router ?? (routerEnabled(process.env) ? sumResultCosts(join53(ctx.repoDir, ".loki"), iterIds).router : undefined), ctx.model);
+      const routeBlock = buildRouteBlock(process.env, ctx.provider, o.implement?.route ?? o.plan?.route_record ?? (routerEnabled(process.env) ? loadRouteRecord(ctx.runDir) : undefined), cost.router ?? (routerEnabled(process.env) ? sumResultCosts(join59(ctx.repoDir, ".loki"), iterIds).router : undefined), ctx.model);
       if (routeBlock)
         for (const l of routeNotProven(routeBlock))
           notProven.add(l);
@@ -12949,7 +13963,7 @@ var init_seal = __esm(() => {
         provider: ctx.provider,
         model: ctx.model,
         resumed: o.intake?.resumed === true,
-        events_sha256: sha2562(existsSync33(eventsPath) ? readFileSync39(eventsPath) : ""),
+        events_sha256: sha2562(existsSync37(eventsPath) ? readFileSync44(eventsPath) : ""),
         ...await sealEvidence(ctx.repoDir, ctx.runDir, o, notProven, signal, ctx.emit),
         log_seal: true,
         ...receiptBlock(process.env, cost.usd, cost.unmetered === true, totalS),
@@ -12969,11 +13983,11 @@ var init_seal = __esm(() => {
         hash = receiptSha256(body);
       }
       const receipt = { ...body, receipt_sha256: hash, verification: { jwt: sig.jwt, kid: sig.kid } };
-      mkdirSync18(ctx.runDir, { recursive: true });
-      const path = join53(ctx.runDir, "receipt.json");
-      writeFileSync19(path, JSON.stringify(receipt, null, 2) + `
+      mkdirSync23(ctx.runDir, { recursive: true });
+      const path = join59(ctx.runDir, "receipt.json");
+      writeFileSync24(path, JSON.stringify(receipt, null, 2) + `
 `);
-      writeFileSync19(join53(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
+      writeFileSync24(join59(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
       recordRun(process.env, ctx.repoDir, ctx.model, verdict, cost.usd, cost.unmetered === true, totalS);
       const signed = sig.jwt !== null;
       const data = { receipt_path: path, receipt_sha256: hash, signed, kid: sig.kid, verdict, not_proven: receipt.not_proven, ...mp ? { mutation_line: mp.line } : {}, ...routeBlock ? { route_line: routePrLine(routeBlock) } : {} };
@@ -12988,7 +14002,7 @@ var init_seal = __esm(() => {
 
 // ../../loki-ts/src/features/receipt_dsse.ts
 import { createPublicKey as createPublicKey3, sign as sign2, verify as verify2 } from "crypto";
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync45 } from "fs";
 function pae(payloadType, body) {
   const t = Buffer.from(payloadType, "utf8");
   return Buffer.concat([Buffer.from(`DSSEv1 ${t.length} `), t, Buffer.from(` ${body.length} `), body]);
@@ -13065,7 +14079,7 @@ function verifyDsseReceipt(env, d) {
 }
 function runIdGuard(receiptPath, runId) {
   try {
-    return envelopeRunIdProblem(JSON.parse(readFileSync40(receiptPath, "utf8")), runId);
+    return envelopeRunIdProblem(JSON.parse(readFileSync45(receiptPath, "utf8")), runId);
   } catch {
     return null;
   }
@@ -13079,16 +14093,16 @@ var init_keys_cmd = __esm(() => {
 });
 
 // ../../loki-ts/src/engine10/verify_cmd.ts
-import { existsSync as existsSync34, readdirSync as readdirSync17, readFileSync as readFileSync41, statSync as statSync18 } from "fs";
-import { dirname as dirname24, join as join54 } from "path";
-import { createHash as createHash13, createPublicKey as createPublicKey4, verify as verify3 } from "crypto";
+import { existsSync as existsSync38, readdirSync as readdirSync19, readFileSync as readFileSync46, statSync as statSync20 } from "fs";
+import { dirname as dirname27, join as join60 } from "path";
+import { createHash as createHash15, createPublicKey as createPublicKey4, verify as verify3 } from "crypto";
 function pubFor(kid, given) {
   if (given)
     return kidOf2(given) === kid ? given : undefined;
   const active = loadSigningKey(false);
   const pubs = (process.env["LOKI_RECEIPT_RETIRED_PUBKEYS"] ?? "").split(":").map((f) => f.trim()).filter(Boolean).flatMap((f) => {
     try {
-      return [createPublicKey4(readFileSync41(f))];
+      return [createPublicKey4(readFileSync46(f))];
     } catch {
       return [];
     }
@@ -13118,18 +14132,18 @@ function checkAttestation(jwt, expectedHash, given) {
 }
 function checkEventLog(receiptPath, receipt) {
   const bound = receipt["events_sha256"];
-  if (typeof bound !== "string" || bound === createHash13("sha256").digest("hex"))
+  if (typeof bound !== "string" || bound === createHash15("sha256").digest("hex"))
     return null;
-  const path = join54(dirname24(receiptPath), "events.jsonl");
-  if (!existsSync34(path))
+  const path = join60(dirname27(receiptPath), "events.jsonl");
+  if (!existsSync38(path))
     return "events.jsonl is missing";
-  const raw2 = readFileSync41(path, "utf8"), events2 = readEvents(path), lines = raw2.split(`
+  const raw2 = readFileSync46(path, "utf8"), events2 = readEvents(path), lines = raw2.split(`
 `).filter((l) => l.trim() !== "");
   if (events2.length !== lines.length || events2.some((e, i) => e.seq !== i))
     return "events.jsonl has a forged, edited or missing line";
   if (events2.some((e) => e.type === "tamper.detected"))
     return "the supervisor detected events.jsonl being modified during the run";
-  const h = createHash13("sha256");
+  const h = createHash15("sha256");
   for (const l of lines) {
     if (h.copy().digest("hex") === bound)
       return null;
@@ -13139,7 +14153,7 @@ function checkEventLog(receiptPath, receipt) {
   return h.digest("hex") === bound ? null : "events.jsonl does not match the hash recorded at seal";
 }
 function checkLogSeal(receiptPath, hash, kid, given) {
-  const path = join54(dirname24(receiptPath), "events.jsonl"), events2 = readEvents(path), done = events2.findIndex((e) => e.type === "run.completed");
+  const path = join60(dirname27(receiptPath), "events.jsonl"), events2 = readEvents(path), done = events2.findIndex((e) => e.type === "run.completed");
   if (!events2.some((e) => e.type === "receipt.sealed" && e.data["receipt_sha256"] === hash))
     return { verdict: "TAMPERED", reason: "events.jsonl has no receipt.sealed event for this receipt" };
   if (done < 0)
@@ -13147,8 +14161,8 @@ function checkLogSeal(receiptPath, hash, kid, given) {
   const seal = events2[done + 1], d = seal?.type === "log.sealed" ? seal.data : null;
   if (!d)
     return { verdict: "TAMPERED", reason: "events.jsonl has no signed log.sealed line after run.completed" };
-  const lines = readFileSync41(path, "utf8").split(`
-`).filter((l) => l.trim() !== ""), sha3 = createHash13("sha256").update(lines.slice(0, done + 1).join(`
+  const lines = readFileSync46(path, "utf8").split(`
+`).filter((l) => l.trim() !== ""), sha3 = createHash15("sha256").update(lines.slice(0, done + 1).join(`
 `) + `
 `).digest("hex");
   const pub = d["kid"] === kid ? pubFor(kid, given) : undefined;
@@ -13157,11 +14171,11 @@ function checkLogSeal(receiptPath, hash, kid, given) {
   return null;
 }
 async function verifyReceipt(receiptPath, deps = {}) {
-  if (!existsSync34(receiptPath))
+  if (!existsSync38(receiptPath))
     return { verdict: "UNCHECKED", reasons: [`receipt not found: ${receiptPath}`] };
   let receipt;
   try {
-    receipt = JSON.parse((deps.read ?? ((p) => readFileSync41(p, "utf8")))(receiptPath));
+    receipt = JSON.parse((deps.read ?? ((p) => readFileSync46(p, "utf8")))(receiptPath));
   } catch {
     return { verdict: "UNCHECKED", reasons: ["receipt.json is not valid JSON"] };
   }
@@ -13216,8 +14230,8 @@ var init_verify_cmd = __esm(() => {
 });
 
 // src/server/app.ts
-import { existsSync as existsSync36, readFileSync as readFileSync44, statSync as statSync19 } from "fs";
-import { join as join57, resolve as resolve13, sep as sep14 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync49, statSync as statSync21 } from "fs";
+import { join as join63, resolve as resolve15, sep as sep14 } from "path";
 
 // node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = Symbol();
@@ -23464,9 +24478,9 @@ function mount20(ctx) {
 }
 
 // src/server/routes/verify.ts
-import { readFileSync as readFileSync42, realpathSync as realpathSync20 } from "fs";
+import { readFileSync as readFileSync47, realpathSync as realpathSync20 } from "fs";
 import { createPublicKey as createPublicKey5 } from "crypto";
-import { join as join55, sep as sep13 } from "path";
+import { join as join61, sep as sep13 } from "path";
 init_verify_cmd();
 init_seal();
 init_receipt_dsse();
@@ -23493,11 +24507,11 @@ function mount21(ctx) {
       return done(404, "receipt not available", "not_found");
     let runDir, file;
     try {
-      const root = realpathSync20(join55(repo.p, ".loki", "runs"));
-      runDir = realpathSync20(join55(root, run2));
-      if (runDir !== join55(root, run2))
+      const root = realpathSync20(join61(repo.p, ".loki", "runs"));
+      runDir = realpathSync20(join61(root, run2));
+      if (runDir !== join61(root, run2))
         return done(404, "receipt not found", "not_found");
-      file = realpathSync20(join55(runDir, "receipt.json"));
+      file = realpathSync20(join61(runDir, "receipt.json"));
     } catch {
       return done(404, "receipt not found", "not_found");
     }
@@ -23516,7 +24530,7 @@ function mount21(ctx) {
         sha3 = r.receiptSha256 ?? null;
       }
       try {
-        outcome = outcomeOf(JSON.parse(readFileSync42(file, "utf8")));
+        outcome = outcomeOf(JSON.parse(readFileSync47(file, "utf8")));
       } catch {
         outcome = "UNREADABLE";
       }
@@ -23578,8 +24592,8 @@ function ttlCache(ttlMs = PROBE_CACHE_MS, now2 = Date.now) {
 }
 
 // src/server/legacy/shim.ts
-import { existsSync as existsSync35, readFileSync as readFileSync43 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync48 } from "fs";
+import { join as join62 } from "path";
 
 // src/server/legacy/routes.ts
 var LEGACY_ROUTES = [
@@ -23951,10 +24965,10 @@ var logged = new Set;
 var toHono = (p) => p.replace(/\{([A-Za-z_]+):path\}/g, ":$1{.+}").replace(/\{([A-Za-z_]+)\}/g, ":$1");
 var NOT_SUPPORTED = "not yet supported by the Control Plane";
 var repoVersion = () => {
-  for (const f of [join56(import.meta.dir, "../../../../../VERSION")]) {
+  for (const f of [join62(import.meta.dir, "../../../../../VERSION")]) {
     try {
-      if (existsSync35(f))
-        return readFileSync43(f, "utf8").trim();
+      if (existsSync39(f))
+        return readFileSync48(f, "utf8").trim();
     } catch {}
   }
   return "unknown";
@@ -24136,7 +25150,7 @@ function legacyShim(opts) {
 
 // src/server/app.ts
 var MAX_BODY2 = 1e6;
-var defaultUiDir = () => [join57(import.meta.dir, "../../ui/dist"), join57(import.meta.dir, "../ui/dist")].find((d) => existsSync36(join57(d, "index.html")));
+var defaultUiDir = () => [join63(import.meta.dir, "../../ui/dist"), join63(import.meta.dir, "../ui/dist")].find((d) => existsSync40(join63(d, "index.html")));
 function createApp(opts) {
   const uiDir = opts.uiDir ?? defaultUiDir();
   const { db, sqlite } = openDb(opts.dbPath);
@@ -24165,10 +25179,10 @@ function createApp(opts) {
     await next();
   });
   const readInstalled = () => {
-    for (const f of [process.env.LOKI_VERSION_FILE, join57(import.meta.dir, "../../../../VERSION")]) {
+    for (const f of [process.env.LOKI_VERSION_FILE, join63(import.meta.dir, "../../../../VERSION")]) {
       try {
         if (f)
-          return readFileSync44(f, "utf8").trim() || "unknown";
+          return readFileSync49(f, "utf8").trim() || "unknown";
       } catch {}
     }
     return "unknown";
@@ -24277,13 +25291,13 @@ function createApp(opts) {
     }
     if (!uiDir || p.startsWith("/v1/"))
       return c.json({ error: "not found" }, 404);
-    const root = resolve13(uiDir);
-    const f = resolve13(root, `.${p}`);
-    if (f.startsWith(root + sep14) && existsSync36(f) && statSync19(f).isFile())
+    const root = resolve15(uiDir);
+    const f = resolve15(root, `.${p}`);
+    if (f.startsWith(root + sep14) && existsSync40(f) && statSync21(f).isFile())
       return new Response(Bun.file(f));
     if (/\.[a-z0-9]+$/i.test(p))
       return c.json({ error: "not found" }, 404);
-    return new Response(Bun.file(join57(root, "index.html")));
+    return new Response(Bun.file(join63(root, "index.html")));
   });
   return { app, db, close: () => {
     clearInterval(reconciler);