loki-mode 11.3.0 → 11.3.1

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

@@ -14,6 +14,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // node_modules/yaml/dist/nodes/identity.js
@@ -6958,9 +6959,292 @@ var require_public_api = __commonJS((exports) => {
   exports.stringify = stringify;
 });
 
+// ../../loki-ts/src/util/paths.ts
+import { resolve as resolve7, dirname as dirname6 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync14 } from "fs";
+import { homedir as homedir7 } from "os";
+function findRepoRoot() {
+  let dir = HERE;
+  for (let i = 0;i < 6; i++) {
+    if (existsSync14(resolve7(dir, "VERSION")) && existsSync14(resolve7(dir, "autonomy/run.sh"))) {
+      return dir;
+    }
+    const parent = dirname6(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return resolve7(HERE, "..", "..", "..");
+}
+function homeLokiDir() {
+  return resolve7(homedir7(), ".loki");
+}
+var HERE, REPO_ROOT;
+var init_paths = __esm(() => {
+  HERE = dirname6(fileURLToPath(import.meta.url));
+  REPO_ROOT = findRepoRoot();
+});
+
+// ../../loki-ts/src/features/lean_prefix.ts
+var LEAN_PREFIX, STAGE_PREFIX;
+var init_lean_prefix = __esm(() => {
+  LEAN_PREFIX = "You are Loki, an autonomous coding agent. Follow the task prompt exactly " + "and report only what you did.";
+  STAGE_PREFIX = "You are Loki, an autonomous coding agent working one stage of a run. " + "Follow the stage prompt exactly, including the role it gives you and the rules it sets, " + "and report only what you did. " + "Stage-specific instructions and the task follow this block.";
+});
+
+// ../../loki-ts/src/util/claude_model.ts
+var FAMILY_ALIASES;
+var init_claude_model = __esm(() => {
+  init_paths();
+  FAMILY_ALIASES = new Set(["haiku", "sonnet", "opus", "fable"]);
+});
+
+// ../../loki-ts/src/runner/router/flag.ts
+function routerMode(env = process.env) {
+  const v = (env.LOKI_ROUTER ?? "").trim().toLowerCase();
+  if (v === "0" || v === "false" || v === "off")
+    return "opt-out";
+  if (v === "1" || v === "true" || v === "on")
+    return "on";
+  return "off";
+}
+var routerEnabled = (env = process.env) => routerMode(env) === "on";
+
+// ../../loki-ts/src/engine10/cost.ts
+import { mkdirSync as mkdirSync6, readdirSync as readdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "fs";
+import { join as join27 } from "path";
+function routerTelemetryOn(env = process.env) {
+  return routerEnabled(env);
+}
+function num3(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function resultCostPath(lokiRoot, iteration) {
+  return join27(lokiRoot, "metrics", `result-cost-${iteration}.json`);
+}
+function sumResultCosts(lokiRoot, iterations) {
+  const out2 = {
+    usd: null,
+    partialUsd: 0,
+    measuredCount: 0,
+    totalCount: iterations.length,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_creation_tokens: 0,
+    ...routerTelemetryOn() ? { router: {
+      requests_total: 0,
+      requests_over_100k: 0,
+      over_100k_input_tokens: 0,
+      over_100k_output_tokens: 0,
+      advisor_calls: 0,
+      advisor_input_tokens: 0,
+      advisor_output_tokens: 0
+    } } : {},
+    model: null,
+    source: "",
+    missing: []
+  };
+  const sources2 = [];
+  let usd = 0;
+  for (const iter of iterations) {
+    const path = resultCostPath(lokiRoot, iter);
+    let rec;
+    try {
+      rec = JSON.parse(readFileSync19(path, "utf8"));
+    } catch {
+      out2.missing.push(iter);
+      continue;
+    }
+    const inTok = num3(rec["input_tokens"]);
+    const outTok = num3(rec["output_tokens"]);
+    const cacheR = num3(rec["cache_read_tokens"]);
+    const cacheC = num3(rec["cache_creation_tokens"]);
+    out2.input_tokens += inTok;
+    out2.output_tokens += outTok;
+    out2.cache_read_tokens += cacheR;
+    out2.cache_creation_tokens += cacheC;
+    if (out2.router)
+      out2.router["requests_total"] += num3(rec["requests_total"]);
+    if (out2.router)
+      out2.router["requests_over_100k"] += num3(rec["requests_over_100k"]);
+    if (out2.router)
+      out2.router["over_100k_input_tokens"] += num3(rec["over_100k_input_tokens"]);
+    if (out2.router)
+      out2.router["over_100k_output_tokens"] += num3(rec["over_100k_output_tokens"]);
+    if (out2.router)
+      out2.router["advisor_calls"] += num3(rec["advisor_calls"]);
+    if (out2.router)
+      out2.router["advisor_input_tokens"] += num3(rec["advisor_input_tokens"]);
+    if (out2.router)
+      out2.router["advisor_output_tokens"] += num3(rec["advisor_output_tokens"]);
+    if (typeof rec["model"] === "string" && rec["model"])
+      out2.model = rec["model"];
+    sources2.push(path);
+    const c = rec["total_cost_usd"];
+    const unmetered = rec["source"] === UNMETERED;
+    if (unmetered)
+      out2.unmetered = true;
+    const noUsage = !unmetered && inTok === 0 && outTok === 0 && cacheR === 0 && cacheC === 0;
+    if (typeof c !== "number" || !Number.isFinite(c) || noUsage) {
+      out2.missing.push(iter);
+      continue;
+    }
+    usd += c;
+    out2.partialUsd += c;
+    out2.measuredCount++;
+  }
+  out2.source = sources2.join(",");
+  if (iterations.length > 0 && out2.missing.length === 0)
+    out2.usd = usd;
+  return out2;
+}
+var UNMETERED = "cli-invoker-unmetered";
+var init_cost = () => {};
+
+// ../../loki-ts/src/runner/budget.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readdirSync as readdirSync10, readFileSync as readFileSync20, renameSync as renameSync4, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join28, resolve as resolve9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function _loadPricing() {
+  try {
+    const moduleDir = dirname8(fileURLToPath2(import.meta.url));
+    const jsonPath = resolve9(moduleDir, "..", "..", "data", "model-pricing.json");
+    if (!existsSync16(jsonPath))
+      return _FALLBACK_PRICING;
+    const raw2 = JSON.parse(readFileSync20(jsonPath, "utf8"));
+    const pricing2 = raw2["pricing"];
+    if (!pricing2 || typeof pricing2 !== "object")
+      return _FALLBACK_PRICING;
+    const out2 = {};
+    for (const [key, value] of Object.entries(pricing2)) {
+      if (value !== null && typeof value === "object" && typeof value.input === "number" && typeof value.output === "number") {
+        const _e = value;
+        out2[key] = {
+          input: _e.input,
+          output: _e.output,
+          ...typeof _e.cache_read === "number" ? { cache_read: _e.cache_read } : {},
+          ...typeof _e.cache_write === "number" ? { cache_write: _e.cache_write } : {},
+          ...typeof _e.cache_write_5m === "number" ? { cache_write_5m: _e.cache_write_5m } : {},
+          ...typeof _e.cache_write_1h === "number" ? { cache_write_1h: _e.cache_write_1h } : {},
+          ..._e.over_100k && typeof _e.over_100k.input === "number" && typeof _e.over_100k.output === "number" ? { over_100k: _e.over_100k } : {}
+        };
+      }
+    }
+    for (const k of Object.keys(_FALLBACK_PRICING)) {
+      if (!(k in out2))
+        return _FALLBACK_PRICING;
+    }
+    return out2;
+  } catch {
+    return _FALLBACK_PRICING;
+  }
+}
+var _FALLBACK_PRICING, PRICING;
+var init_budget = __esm(() => {
+  init_paths();
+  init_cost();
+  _FALLBACK_PRICING = {
+    fable: { input: 10, output: 50, cache_read: 0.25, cache_write: 12.5, cache_write_5m: 12.5, cache_write_1h: 20 },
+    opus: { input: 4, output: 20, cache_read: 0.2, cache_write: 5, cache_write_5m: 5, cache_write_1h: 8 },
+    sonnet: { input: 2, output: 10, cache_read: 0.1, cache_write: 2.5, cache_write_5m: 2.5, cache_write_1h: 4 },
+    haiku: {
+      input: 0.1,
+      output: 0.5,
+      cache_read: 0.01,
+      cache_write: 0.125,
+      cache_write_5m: 0.125,
+      cache_write_1h: 0.2,
+      over_100k: { input: 0.5, output: 2.5, cache_read: 0.05, cache_write: 0.625, cache_write_5m: 0.625, cache_write_1h: 1 }
+    },
+    "claude-haiku-4-5": { input: 1, output: 5, cache_read: 0.1, cache_write: 1.25, cache_write_5m: 1.25, cache_write_1h: 2 },
+    "claude-haiku-5-5": {
+      input: 0.1,
+      output: 0.5,
+      cache_read: 0.01,
+      cache_write: 0.125,
+      over_100k: { input: 0.5, output: 2.5, cache_read: 0.05, cache_write: 0.625 }
+    },
+    "gpt-5.3-codex": { input: 1.75, output: 14, cache_read: 0.175, cache_write: 2.1875 }
+  };
+  PRICING = Object.freeze(_loadPricing());
+});
+
+// ../../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;
+});
+
 // src/server/app.ts
-import { existsSync as existsSync24, readFileSync as readFileSync31, statSync as statSync15 } from "fs";
-import { join as join40, resolve as resolve8, sep as sep14 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync40, statSync as statSync17 } from "fs";
+import { join as join53, resolve as resolve12, sep as sep14 } from "path";
 
 // node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = Symbol();
@@ -17519,365 +17803,39 @@ function mount20(ctx) {
 }
 
 // src/server/routes/verify.ts
-import { readFileSync as readFileSync29, realpathSync as realpathSync17 } from "fs";
+import { readFileSync as readFileSync38, realpathSync as realpathSync20 } from "fs";
 import { createPublicKey as createPublicKey5 } from "crypto";
-import { join as join38, sep as sep13 } from "path";
+import { join as join51, sep as sep13 } from "path";
 
 // ../../loki-ts/src/engine10/verify_cmd.ts
-import { existsSync as existsSync22, readdirSync as readdirSync13, readFileSync as readFileSync28, statSync as statSync14 } from "fs";
-import { dirname as dirname14, join as join37 } from "path";
-import { createHash as createHash10, createPublicKey as createPublicKey4, verify as verify3 } from "crypto";
-
-// ../../loki-ts/src/util/paths.ts
-import { resolve as resolve7, dirname as dirname6 } from "path";
-import { fileURLToPath } from "url";
-import { existsSync as existsSync14 } from "fs";
-var HERE = dirname6(fileURLToPath(import.meta.url));
-function findRepoRoot() {
-  let dir = HERE;
-  for (let i = 0;i < 6; i++) {
-    if (existsSync14(resolve7(dir, "VERSION")) && existsSync14(resolve7(dir, "autonomy/run.sh"))) {
-      return dir;
-    }
-    const parent = dirname6(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  return resolve7(HERE, "..", "..", "..");
-}
-var REPO_ROOT = findRepoRoot();
+init_paths();
+import { existsSync as existsSync31, readdirSync as readdirSync15, readFileSync as readFileSync37, statSync as statSync16 } from "fs";
+import { dirname as dirname22, join as join50 } from "path";
+import { createHash as createHash12, createPublicKey as createPublicKey4, verify as verify3 } from "crypto";
 
 // ../../loki-ts/src/engine10/stages/seal.ts
-import { createHash as createHash9, randomBytes as randomBytes3, createPrivateKey, createPublicKey as createPublicKey2, generateKeyPairSync, sign } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync21, readdirSync as readdirSync12, linkSync, mkdirSync as mkdirSync10, readFileSync as readFileSync26, statSync as statSync13, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir7 } from "os";
-import { basename as basename11, dirname as dirname13, join as join36 } from "path";
+import { createHash as createHash11, randomBytes as randomBytes3, createPrivateKey, createPublicKey as createPublicKey2, generateKeyPairSync, sign } from "crypto";
+import { chmodSync as chmodSync5, existsSync as existsSync30, readdirSync as readdirSync14, linkSync, mkdirSync as mkdirSync17, readFileSync as readFileSync35, statSync as statSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync18 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename as basename17, dirname as dirname21, join as join49 } from "path";
 
-// ../../loki-ts/src/e10ext/assert_delta.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, rmSync as rmSync4 } from "fs";
+// ../../loki-ts/src/util/mutation_proof.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, rmSync as rmSync4, symlinkSync, writeFileSync as writeFileSync8 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join26 } from "path";
-import { basename as basename8 } from "path";
-var WEAKENED = { verdict: "weakened", changes: [] };
-var PY = String.raw`
-import ast, copy, io, json, re, sys, tokenize
-d = json.load(sys.stdin)
-bs, hs, task = d["base"], d["head"], d["task"]
-def out(v, it=()):
-    print(json.dumps({"verdict": v, "items": list(it)}))
-    sys.exit(0)
-if "\r" in bs or "\r" in hs or "\t" in bs or "\t" in hs:
-    out("weakened")
-bt, ht = ast.parse(bs), ast.parse(hs)
-# every byte outside a literal token (comments, blank lines, spacing, other code) must be identical
-def template(src):
-    lines = src.split("\n")
-    starts, o = [], 0
-    for ln in lines:
-        starts.append(o)
-        o += len(ln) + 1
-    spans = [(starts[t.start[0] - 1] + t.start[1], starts[t.end[0] - 1] + t.end[1])
-             for t in tokenize.generate_tokens(io.StringIO(src).readline) if t.type in (tokenize.STRING, tokenize.NUMBER)]
-    r, pos = [], 0
-    for a, b in spans:
-        r.append(src[pos:a] + "\0")
-        pos = b
-    return "".join(r) + src[pos:]
-if template(bs) != template(hs):
-    out("weakened")
-class Norm(ast.NodeTransformer):
-    def visit_Constant(self, n):
-        return ast.copy_location(ast.Constant(value="<" + type(n.value).__name__ + ">"), n)
-def norm(t):
-    return ast.dump(Norm().visit(copy.deepcopy(t)))
-# only what pytest collects: module-level test functions and methods of Test* classes without __init__
-def tests(t):
-    r = []
-    for n in t.body:
-        if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name.startswith("test"):
-            r.append(n)
-        elif isinstance(n, ast.ClassDef) and n.name.startswith("Test") \
-                and not any(isinstance(m, (ast.FunctionDef, ast.AsyncFunctionDef)) and m.name == "__init__" for m in n.body):
-            r += [m for m in n.body if isinstance(m, (ast.FunctionDef, ast.AsyncFunctionDef)) and m.name.startswith("test")]
-    return r
-def direct(f):
-    return [a for a in f.body if isinstance(a, ast.Assert)]
-def tables(t):
-    return [n.args[1] for n in ast.walk(t) if isinstance(n, ast.Call) and getattr(n.func, "attr", "") == "parametrize"
-            and len(n.args) > 1 and isinstance(n.args[1], (ast.List, ast.Tuple))]
-def stripped(t):
-    c = copy.deepcopy(t)
-    for tb in tables(c):
-        tb.elts = []
-    return c
-def consts(t):
-    return [n for n in ast.walk(t) if isinstance(n, ast.Constant)]
-def shadowed(t):
-    for scope in [t] + [n for n in t.body if isinstance(n, ast.ClassDef)]:
-        names = [n.name for n in scope.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name.startswith("test")]
-        if len(names) != len(set(names)):
-            return True
-    return False
-if shadowed(bt) or shadowed(ht):
-    out("weakened")
-sb, sh = stripped(bt), stripped(ht)
-if not tests(ht) or norm(sb) != norm(sh):
-    out("weakened")
-for t in (bt, ht):
-    if any(isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "round" for n in ast.walk(t)):
-        out("weakened")
-tb, th = tables(bt), tables(ht)
-if any(len(x.elts) != len(y.elts) for x, y in zip(tb, th)):
-    out("weakened")
-if any(norm(r) != norm(q) for x, y in zip(tb, th) for r, q in zip(x.elts, y.elts)):
-    out("weakened")
-owner = {}
-for f in tests(sh):
-    for n in ast.walk(f):
-        owner[id(n)] = f
-pairs = [(b, h, owner.get(id(h))) for b, h in zip(consts(sb), consts(sh))]
-fh = {}
-for f in tests(ht):
-    for t in tables(f):
-        fh[id(t)] = f
-for x, y in zip(tb, th):
-    for r, q in zip(x.elts, y.elts):
-        pairs += [(b, h, fh.get(id(y))) for b, h in zip(consts(r), consts(q))]
-def eqs(f):
-    return [a.test for a in direct(f) if isinstance(a.test, ast.Compare) and len(a.test.ops) == 1 and isinstance(a.test.ops[0], ast.Eq)]
-def dups(t):
-    r = {}
-    for f in tests(t):
-        ds = [ast.dump(a) for a in direct(f)]
-        r[f.name] = len(ds) - len(set(ds))
-    return r
-dh, db = dups(ht), dups(bt)
-ok = not any(v > db.get(k, 0) for k, v in dh.items())
-# expected side = the right operand of a direct "assert X == Y"
-exp = set()
-for f in tests(sh):
-    exp |= {id(c.comparators[0]) for c in eqs(f) if isinstance(c.comparators[0], ast.Constant)}
-for f in tests(ht):
-    rights = {id(c.comparators[0]) for c in eqs(f) if isinstance(c.comparators[0], ast.Name)}
-    for c in f.decorator_list:
-        if isinstance(c, ast.Call) and getattr(c.func, "attr", "") == "parametrize" and len(c.args) > 1 \
-                and isinstance(c.args[0], ast.Constant) and isinstance(c.args[0].value, str) and isinstance(c.args[1], (ast.List, ast.Tuple)):
-            cols = [x.strip() for x in c.args[0].value.split(",")]
-            # a column counts only if every use of its name in the body is the right operand of a direct eq assert
-            if any(kw.arg == "indirect" for kw in c.keywords):
-                continue
-            deco = {id(m) for dd in f.decorator_list for m in ast.walk(dd)}
-            uses = {k: [n for n in ast.walk(f) if isinstance(n, ast.Name) and n.id == k and id(n) not in deco] for k in cols}
-            # the column must be read at least once, and only as the right operand of a direct eq assert
-            solo = {k for k, u in uses.items() if u and all(id(n) in rights for n in u)}
-            for r in c.args[1].elts:
-                for i, e in enumerate(r.elts if isinstance(r, (ast.Tuple, ast.List)) else [r]):
-                    if isinstance(e, ast.Constant) and i < len(cols) and cols[i] in solo:
-                        exp.add(id(e))
-def callees(f):
-    r = set()
-    for c in eqs(f):
-        for n in ast.walk(c.left):
-            if isinstance(n, ast.Call):
-                k = n.func.id if isinstance(n.func, ast.Name) else getattr(n.func, "attr", "")
-                if k:
-                    r.add(k)
-    return r
-def generic(v):
-    return v is None or isinstance(v, (bool, bytes)) or (isinstance(v, str) and len(v) <= 3) \
-        or (isinstance(v, (int, float)) and abs(v) < 10)
-def in_task(v, f):
-    task0 = d["task"]
-    t = v if isinstance(v, str) else repr(v)
-    if t == "":
-        return False
-    # bounded by whitespace, string ends or ,;:()[]{}"' only; never glued to - + or a digit group separator
-    tok = r"(?<![^\s,;:()\[\]{}\"'])(?<!\d,)" + re.escape(t) + r"(?:(?=[\s,;:()\[\]{}\"']|$)(?!,\d)|\.(?=\s|$))"
-    task = re.sub(r"(?<=\d),(?=\d{3}\b)", "", task0)
-    if not generic(v):
-        return re.search(tok, task) is not None
-    # a generic value counts only right next to the identifier the test calls
-    return any(re.search(r"\b" + re.escape(k) + r"\b[^\n]{0,40}?" + tok, task) for k in (callees(f) if f else ()))
-items = []
-for b, h, f in pairs:
-    if (type(b.value), repr(b.value)) != (type(h.value), repr(h.value)):
-        hit = in_task(h.value, f)
-        ok = ok and id(h) in exp and hit
-        items.append({"line": h.lineno, "old": repr(b.value), "new": repr(h.value), "inTask": hit, "matched": "new"})
-out("value-change" if ok and items else "weakened", items if ok else [])
-`;
-var okStr = (v) => typeof v === "string" && v.length <= 200 && !/[\x00-\x1f\x7f]/.test(v);
-function classifyAssertDelta(inp) {
-  const f = basename8(inp.path);
-  if (!/^(test_.*|.*_test)\.py$/.test(f))
-    return WEAKENED;
-  if (inp.headCounts.run !== inp.baseCounts.run || inp.headCounts.skipped !== inp.baseCounts.skipped)
-    return WEAKENED;
-  let cwd = "";
-  try {
-    cwd = mkdtempSync2(join26(tmpdir3(), "loki-ad-"));
-    const raw2 = execFileSync4("python3", ["-I", "-c", PY], {
-      input: JSON.stringify({ path: inp.path, base: inp.base, head: inp.head, task: inp.task }),
-      cwd,
-      env: process.env,
-      stdio: ["pipe", "pipe", "ignore"],
-      encoding: "utf8",
-      timeout: 20000
-    });
-    const r = JSON.parse(raw2);
-    if (r.verdict !== "value-change" || !Array.isArray(r.items) || r.items.length === 0)
-      return WEAKENED;
-    const items = [];
-    for (const i of r.items) {
-      if (!i || typeof i !== "object" || !Number.isInteger(i["line"]) || i["line"] < 1 || !okStr(i["old"]) || !okStr(i["new"]) || i["inTask"] !== true || i["matched"] !== "new")
-        return WEAKENED;
-      items.push({ line: i["line"], old: i["old"], new: i["new"], matched: "new" });
-    }
-    return { verdict: "value-change", changes: items.map((i) => `${inp.path}:${i.line} ${i.old} -> ${i.new}`), items };
-  } catch {
-    return WEAKENED;
-  } finally {
-    if (cwd)
-      rmSync4(cwd, { recursive: true, force: true });
-  }
-}
-function assertDeltaNotes(repoDir, baseSha, headRef, path, task, baseCounts, headCounts) {
-  if (!baseCounts || !headCounts)
-    return null;
-  try {
-    const show = (ref) => execFileSync4("git", ["show", `${ref}:${path}`], { cwd: repoDir, encoding: "utf8", env: process.env, stdio: ["ignore", "pipe", "ignore"] });
-    const head = headRef ? show(headRef) : readFileSync18(join26(repoDir, path), "utf8");
-    const r = classifyTestEdit(path, show(baseSha), head, task, baseCounts, headCounts);
-    return r[0]?.kind === "literal-only" ? r.map((e) => `assertion value changed (not shown to be required by the task): ${e.file}:${e.line} ${e.old} -> ${e.new}`) : null;
-  } catch {
-    return null;
-  }
-}
-function classifyTestEdit(file, oldText, newText, taskText, baseCounts, headCounts) {
-  const weak = [{ kind: "weakened", file, line: 0, old: "", new: "", inTask: false }];
-  const r = classifyAssertDelta({ path: file, base: oldText, head: newText, task: taskText, baseCounts, headCounts });
-  if (r.verdict !== "value-change" || !r.items?.length)
-    return weak;
-  return r.items.map((i) => ({ kind: "literal-only", file, line: i.line, old: i.old, new: i.new, inTask: true }));
-}
-
-// ../../loki-ts/src/e10ext/discard.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { chmodSync as chmodSync4, closeSync as closeSync5, lstatSync as lstatSync4, mkdirSync as mkdirSync5, openSync as openSync5, readFileSync as readFileSync19, realpathSync as realpathSync14, rmdirSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname7, join as join27, relative, sep as sep9 } from "path";
-function safeRestore(repoDir, f, want, mode) {
-  const root = realpathSync14(repoDir), fp = join27(root, f), rel = relative(root, dirname7(fp));
-  if (rel.startsWith(".."))
-    throw new Error("outside repo");
-  let cur = root;
-  for (const part of rel === "" ? [] : rel.split(sep9)) {
-    cur = join27(cur, part);
-    let st2;
-    try {
-      st2 = lstatSync4(cur);
-    } catch {
-      mkdirSync5(cur);
-      continue;
-    }
-    if (!st2.isDirectory())
-      throw new Error("parent is not a real directory");
-  }
-  let st;
-  try {
-    st = lstatSync4(fp);
-  } catch {
-    st = null;
-  }
-  if (st?.isFile() && readFileSync19(fp).equals(want)) {
-    chmodSync4(fp, mode);
-    return;
-  }
-  if (st) {
-    if (st.isDirectory())
-      rmdirSync(fp);
-    else
-      unlinkSync3(fp);
-  }
-  const fd = openSync5(fp, "wx", mode);
-  try {
-    writeFileSync8(fd, want);
-  } finally {
-    closeSync5(fd);
-  }
-  chmodSync4(fp, mode);
-}
-function alreadySatisfied(o) {
-  const b = o.wall?.base_run ?? {};
-  return o.intake?.already_satisfied === true || o.implement?.exit === "already_done" || typeof b.pass === "number" && b.pass > 0 && b.fail === 0 && (b.not_run ?? 0) === 0;
-}
-async function discardIfSatisfied(git, base, o, staged, keep, repoDir) {
-  if (!alreadySatisfied(o))
-    return null;
-  const pre = Object.assign(Object.create(null), o.intake?.preexisting_dirty ?? {}), own = new Set([...Array.isArray(o.intake?.preexisting_untracked) ? o.intake.preexisting_untracked : [], ...Object.keys(o.intake?.preexisting_untracked_blobs ?? {})]);
-  const gone = staged.filter(({ f }) => !keep.has(f) && !own.has(f) && !Object.hasOwn(pre, f) && !f.startsWith(".loki/")), lit = ["--literal-pathspecs"];
-  const del = gone.filter(({ st }) => st === "A").map(({ f }) => f), back = gone.filter(({ st }) => st !== "A").map(({ f }) => f);
-  if (del.length > 0 && (await git([...lit, "rm", "-q", "-f", "--", ...del])).code !== 0 || back.length > 0 && (await git([...lit, "restore", `--source=${base}`, "--staged", "--worktree", "--", ...back])).code !== 0 || (await git(["reset", "-q", base])).code !== 0)
-    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 = join27(repoDir, f);
-    try {
-      if (v.startsWith("!")) {
-        const st = lstatSync4(fp);
-        if (`!${st.size}:${st.mtimeMs}:${st.ctimeMs}` !== v)
-          throw new Error("changed, not snapshotted");
-        continue;
-      }
-      const [sha2, mode] = v.split(" "), want = execFileSync5("git", ["cat-file", "blob", sha2], { cwd: repoDir, env: process.env, maxBuffer: 1 << 28 });
-      safeRestore(repoDir, f, want, parseInt(mode ?? "644", 8));
-    } catch {
-      notProven.push(f);
-    }
-  }
-  for (const f of Object.keys(pre))
-    if (staged.some((s) => s.f === f) && !keep.has(f)) {
-      try {
-        let m = 420;
-        try {
-          const l = lstatSync4(join27(repoDir, f));
-          if (l.isFile())
-            m = l.mode & 511;
-        } catch {}
-        safeRestore(repoDir, f, execFileSync5("git", ["cat-file", "blob", pre[f]], { cwd: repoDir, env: process.env, maxBuffer: 1 << 28 }), m);
-      } catch {
-        notProven.push(f);
-      }
-    }
-  return { status: "completed", data: { committed: false, discarded: gone.length, ...notProven.length > 0 ? { not_proven: notProven.map((f) => `pre-existing file not restored: ${f}`) } : {} } };
-}
-
-// ../../loki-ts/src/e10ext/commit_filter.ts
-import { dirname as dirname8 } from "path";
-
-// ../../loki-ts/src/e10ext/preexisting_dirty.ts
-import { execFileSync as execFileSync6 } from "child_process";
-var blob2 = (repoDir, path, env = process.env) => execFileSync6("git", ["hash-object", "-w", "--no-filters", "--", path], { cwd: repoDir, encoding: "utf8", env, stdio: ["ignore", "pipe", "ignore"] }).trim();
-function untouchedSinceIntake(repoDir, recorded, env = process.env) {
-  if (!recorded || typeof recorded !== "object")
-    return [];
-  return Object.entries(recorded).filter(([p, h]) => {
-    try {
-      return blob2(repoDir, p, env) === h;
-    } catch {
-      return false;
-    }
-  }).map(([p]) => p);
-}
+import { basename as basename8, dirname as dirname7, isAbsolute, join as join26, relative } from "path";
 
 // ../../loki-ts/src/util/safe_git.ts
-import { execFileSync as execFileSync7, spawnSync } from "child_process";
+import { execFileSync as execFileSync4, spawnSync } from "child_process";
 var SAFE_GIT_CONFIG = ["-c", "core.fsmonitor=", "-c", "core.hooksPath=/dev/null", "-c", "core.sshCommand=", "-c", "protocol.ext.allow=never", "-c", "credential.helper="];
 var CREDENTIAL_CONFIG = ["-c", "core.fsmonitor=", "-c", "core.hooksPath=/dev/null", "-c", "protocol.ext.allow=never"];
 var DRIVER_CONFIG = ["-c", "diff.external=", "-c", "commit.gpgSign=false", "-c", "core.attributesFile=/dev/null"];
+var ATTRS_OFF = "core.attributesFile=/dev/null";
+var HOOKS_OFF = "core.hooksPath=/dev/null";
+var SIGN_OFF = "commit.gpgSign=false";
 var REPO_SCOPES = new Set(["local", "worktree", "command"]);
-var DRIVER_KEY_RE = "^(filter\\..*\\.(clean|smudge|process)|diff\\..*\\.textconv)$";
+var DRIVER_KEY_RE = "^(filter\\..*\\.(clean|smudge|process)|diff\\..*\\.(textconv|command))$";
+var PATCH_CMDS = new Set(["diff", "show", "log", "whatchanged"]);
+var OPT_WITH_VALUE = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path", "--config-env", "--attr-source"]);
 var SECRET_VARS = ["GH_TOKEN", "GITHUB_TOKEN", "GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN", "SSH_AUTH_SOCK"];
 function tokenFreeEnv(env = process.env) {
   const out2 = { ...env };
@@ -17888,6 +17846,7 @@ function tokenFreeEnv(env = process.env) {
 var safeGitEnv = (base = process.env, allowToken = false) => {
   const env = { ...allowToken ? base : tokenFreeEnv(base), GIT_CONFIG_NOSYSTEM: "1" };
   delete env.GIT_ATTR_SOURCE;
+  delete env.GIT_EXTERNAL_DIFF;
   return env;
 };
 function driverKeys(repoDir) {
@@ -17907,62 +17866,253 @@ function driverKeys(repoDir) {
   }
   return [...new Set(keys)];
 }
-var safeGitArgs = (args, allowToken = false, repoDir) => [
-  ...allowToken ? CREDENTIAL_CONFIG : SAFE_GIT_CONFIG,
-  ...DRIVER_CONFIG,
-  ...repoDir ? driverKeys(repoDir).flatMap((k) => ["-c", `${k}=`]) : [],
-  ...args
-];
-var safeGitArgv = (args, allowToken = false, repoDir) => ["git", ...safeGitArgs(args, allowToken, repoDir)];
-
-// ../../loki-ts/src/e10ext/commit_filter.ts
-var parseStaged = (out2) => out2.split("\x00").reduce((a, t, i, all) => i % 2 === 0 && t ? [...a, { st: t, f: all[i + 1] }] : a, []);
-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) && dirname8(m) === dirname8(f)) && /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|poetry\.lock|Cargo\.lock|go\.sum)$/.test(f));
+function safeGitArgs(args, allowToken = false, repoDir, keep = {}) {
+  if (keep.userHooks && allowToken)
+    throw new Error("safeGit: userHooks with allowToken is refused (a hook would run holding the credential)");
+  const off = new Set([...keep.repoDrivers ? [ATTRS_OFF] : [], ...keep.userHooks ? [HOOKS_OFF, SIGN_OFF] : []]);
+  const cfg = [...allowToken ? CREDENTIAL_CONFIG : SAFE_GIT_CONFIG, ...DRIVER_CONFIG];
+  const flags = cfg.flatMap((v, i) => i % 2 === 1 && !off.has(v) ? [cfg[i - 1], v] : []);
+  return [...flags, ...repoDir && !keep.repoDrivers ? driverKeys(repoDir).flatMap((k) => ["-c", `${k}=`]) : [], ...noExtDiff(args)];
+}
+function noExtDiff(args) {
+  let i = 0;
+  while (i < args.length && args[i].startsWith("-"))
+    i += OPT_WITH_VALUE.has(args[i]) ? 2 : 1;
+  const cmd = args[i];
+  if (cmd === undefined || !PATCH_CMDS.has(cmd))
+    return [...args];
+  const rest = args.slice(i + 1);
+  const end = rest.indexOf("--");
+  const opts = (end < 0 ? rest : rest.slice(0, end)).filter((a) => a !== "--ext-diff" && a !== "--textconv");
+  return [...args.slice(0, i + 1), "--no-ext-diff", "--no-textconv", ...opts, ...end < 0 ? [] : rest.slice(end)];
+}
+function safeGit(repoDir, args, opts = {}) {
+  const { env, allowToken, repoDrivers, userHooks, ...rest } = opts;
+  const out2 = execFileSync4("git", safeGitArgs(args, allowToken, repoDir, { repoDrivers, userHooks }), { stdio: ["ignore", "pipe", "ignore"], ...rest, cwd: repoDir, env: safeGitEnv(env ?? process.env, allowToken), encoding: "utf8" });
+  return typeof out2 === "string" ? out2 : "";
+}
+function safeGitSpawn(repoDir, args, opts = {}) {
+  const { env, allowToken, repoDrivers, userHooks, ...rest } = opts;
+  let argv;
+  try {
+    argv = safeGitArgs(args, allowToken, repoDir, { repoDrivers, userHooks });
+  } catch (e) {
+    return { pid: 0, output: [], stdout: "", stderr: "", status: null, signal: null, error: e };
+  }
+  return spawnSync("git", argv, { ...rest, cwd: repoDir, env: safeGitEnv(env ?? process.env, allowToken) });
 }
-
-// ../../loki-ts/src/e10ext/scope.ts
-import { basename as basename10, dirname as dirname9 } from "path";
-
-// ../../loki-ts/src/engine10/testmap.ts
-import { basename as basename9, extname, join as join30, relative as relative2, sep as sep11 } from "path";
-
-// ../../loki-ts/src/project_model/discover.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync20, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "fs";
-import { join as join29 } from "path";
-
-// ../../loki-ts/src/engine10/types.ts
-var STAGE_BUDGETS = {
-  intake: { targetS: 15, limitS: 60 },
-  plan: { targetS: 45, limitS: 90 },
-  wall: { targetS: 45, limitS: 90 },
-  implement: { targetS: 180, limitS: 480 },
-  verify: { targetS: 60, limitS: 120 },
-  fix: { targetS: 90, limitS: 180 },
-  commit: { targetS: 5, limitS: 30 },
+async function safeGitRun(repoDir, args, opts = {}) {
+  let argv;
+  try {
+    argv = safeGitArgs(args, opts.allowToken, repoDir, { repoDrivers: opts.repoDrivers, userHooks: opts.userHooks });
+  } catch (e) {
+    return { stdout: "", stderr: String(e), exitCode: 128 };
+  }
+  let proc;
+  try {
+    proc = Bun.spawn({ cmd: ["git", ...argv], cwd: repoDir, env: safeGitEnv(opts.env ?? process.env, opts.allowToken), stdin: "ignore", stdout: "pipe", stderr: "pipe", signal: opts.signal });
+  } catch (e) {
+    return { stdout: "", stderr: String(e), exitCode: 127 };
+  }
+  let timer;
+  if (opts.timeoutMs && opts.timeoutMs > 0)
+    timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+    }, opts.timeoutMs);
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+
+// ../../loki-ts/src/engine10/types.ts
+var STAGE_BUDGETS = {
+  intake: { targetS: 15, limitS: 60 },
+  plan: { targetS: 45, limitS: 90 },
+  wall: { targetS: 45, limitS: 90 },
+  implement: { targetS: 180, limitS: 480 },
+  verify: { targetS: 60, limitS: 120 },
+  fix: { targetS: 90, limitS: 180 },
+  commit: { targetS: 5, limitS: 30 },
   seal: { targetS: 15, limitS: 60 },
   pr: { targetS: 15, limitS: 60 },
   deep: { targetS: null, limitS: 2700 }
 };
 
+// ../../loki-ts/src/util/run_cap.ts
+var MAX_SCOPE_BYTES = 256 * 1024;
+
+// ../../loki-ts/src/util/mutation_proof.ts
+var mutationStrict = (env = process.env) => (env["LOKI_MUTATION_STRICT"] ?? "").trim() === "1";
+var mutationEnabled = (env = process.env) => (env["LOKI_MUTATION_PROOF"] ?? "").trim() !== "0";
+var LABEL = "test fails without the fix: ";
+var np = (reason) => ({ outcome: "inconclusive", line: `${LABEL}inconclusive (${reason})` });
+var MAX_TOTAL_S = 40;
+var DEP_DIRS = ["node_modules", ".venv", "venv"];
+var git = (cwd, args, timeout = 30000) => {
+  try {
+    safeGit(cwd, args, { timeout });
+    return { status: 0 };
+  } catch {
+    return { status: 1 };
+  }
+};
+function mutationProof(i) {
+  const rels = i.wallFiles.map((f) => isAbsolute(f.path) ? relative(i.repoDir, f.path) : f.path);
+  if (rels.length === 0)
+    return np("no Wall tests");
+  const tests = rels.flatMap((rel) => {
+    const c = i.checks.find((k) => k.name.endsWith(`:${rel}`));
+    const idx = c ? c.name.indexOf(":") : -1;
+    return c && idx > 0 ? [{ runner: c.name.slice(0, idx), path: rel }] : [];
+  });
+  if (tests.length === 0)
+    return np("no recorded Wall test command");
+  if (tests.length !== rels.length)
+    return np("a Wall file has no recorded test command");
+  const budgetS = Math.min(i.timeoutS ?? (Number((i.env ?? process.env)["LOKI_MUTATION_PROOF_TIMEOUT_S"] ?? 30) || 30), MAX_TOTAL_S);
+  const deadline = Date.now() + budgetS * 1000, remaining = () => deadline - Date.now();
+  let parent = null, wt = null, added = false;
+  try {
+    parent = mkdtempSync2(join26(tmpdir3(), "loki-mutproof-"));
+    wt = join26(parent, "wt");
+    const add2 = git(i.repoDir, ["worktree", "add", "--detach", wt, i.baseSha], Math.max(1000, Math.min(30000, remaining())));
+    added = existsSync15(wt) || add2.status === 0;
+    if (add2.status !== 0)
+      return np("could not create the base worktree");
+    for (const rel of rels) {
+      const sealed = join26(i.runDir, "wall", basename8(rel)), src = existsSync15(sealed) ? sealed : join26(i.repoDir, rel);
+      if (!existsSync15(src))
+        return np(`Wall file missing: ${rel}`);
+      mkdirSync5(dirname7(join26(wt, rel)), { recursive: true });
+      writeFileSync8(join26(wt, rel), readFileSync18(src));
+    }
+    for (const rel of rels) {
+      const parts = rel.split("/").slice(0, -1);
+      for (let n2 = 0;n2 <= parts.length; n2++) {
+        const anc = parts.slice(0, n2).join("/");
+        for (const d of DEP_DIRS) {
+          const src = join26(i.repoDir, anc, d), dst = join26(wt, anc, d);
+          if (existsSync15(src) && !existsSync15(dst)) {
+            try {
+              symlinkSync(src, dst);
+            } catch {}
+          }
+        }
+      }
+    }
+    let pass = 0, fail = 0, notRun = 0;
+    for (const t of tests) {
+      if (remaining() <= 0)
+        return np("timeout");
+      const r = (typeof i.runner === "function" ? i.runner(remaining()) : i.runner).run(wt, [t]);
+      pass += r.pass;
+      fail += r.fail;
+      notRun += r.not_run ?? 0;
+    }
+    if (remaining() <= 0 && fail === 0)
+      return np("timeout");
+    if (fail > 0)
+      return { outcome: "yes", line: `${LABEL}yes` };
+    if (pass > 0 && notRun === 0)
+      return { outcome: "no", line: `${LABEL}no (warning: the Wall tests also pass on the old code)` };
+    return np("the Wall command did not execute to a result");
+  } catch (e) {
+    return np(`error: ${String(e?.message ?? e).replace(/\s+/g, " ").slice(0, 120)}`);
+  } finally {
+    if (wt && added)
+      git(i.repoDir, ["worktree", "remove", "--force", wt]);
+    if (parent)
+      rmSync4(parent, { recursive: true, force: true });
+  }
+}
+
+// ../../loki-ts/src/engine10/stages/wall.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync6, readFileSync as readFileSync25, readdirSync as readdirSync11, realpathSync as realpathSync17, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute5, join as join39, relative as relative5 } from "path";
+init_lean_prefix();
+
+// ../../loki-ts/src/features/wall_manifest.ts
+var MODS = "(?:(?:public|private|protected|static|readonly|abstract|async|get|set|declare|override)\\s+)*";
+var MEMBER_GRAMMAR = new RegExp(`^(?:@[\\w$.]+(?:\\([^)]*\\))?\\s*)*${MODS}\\*?\\s*(?:[A-Za-z_$][\\w$]*|#[A-Za-z_$][\\w$]*|\\[[^\\]]*\\])\\s*[?!]?\\s*(?:[(<:=]|$)`);
+// ../../loki-ts/src/engine10/sizing.ts
+import { existsSync as existsSync17, readFileSync as readFileSync21 } from "fs";
+import { basename as basename9 } from "path";
+
+// ../../loki-ts/src/engine10/cache.ts
+import { createHash as createHash6 } from "crypto";
+init_paths();
+import { resolve as resolve8 } from "path";
+function repoKey(originUrl, repoDir) {
+  const basis = originUrl && originUrl.trim() !== "" ? originUrl : resolve8(repoDir);
+  return createHash6("sha256").update(basis).digest("hex");
+}
+function defaultCacheRoot() {
+  return resolve8(homeLokiDir(), "cache", "v10");
+}
+function repoCacheDir(key, cacheRoot = defaultCacheRoot()) {
+  return resolve8(cacheRoot, key);
+}
+
+// ../../loki-ts/src/engine10/sizing.ts
+init_claude_model();
+
+// ../../loki-ts/src/engine10/session.ts
+init_cost();
+init_budget();
+var STDERR_TAIL_BYTES = 64 * 1024;
+var ADVISOR_MARKED_STAGES = new Set(["plan", "fix"]);
+
+// ../../loki-ts/src/engine10/sizing.ts
+function namedFiles(task, map) {
+  return (map?.files ?? []).filter((f) => task.toLowerCase().includes(basename9(f).toLowerCase()));
+}
+function loadRepoMap(repomapRef) {
+  if (!repomapRef || !existsSync17(repomapRef))
+    return null;
+  try {
+    return JSON.parse(readFileSync21(repomapRef, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// ../../loki-ts/src/project_model/resolve.ts
+import { join as join33 } from "path";
+
+// ../../loki-ts/src/project_model/discover.ts
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync23, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
+import { join as join32 } from "path";
+
+// ../../loki-ts/src/project_model/gather.ts
+import { createHash as createHash7 } from "crypto";
+import { closeSync as closeSync5, lstatSync as lstatSync5, openSync as openSync5, readFileSync as readFileSync22, readSync as readSync4 } from "fs";
+import { dirname as dirname9, join as join31 } from "path";
+
 // ../../loki-ts/src/project_model/schema.ts
-import { existsSync as existsSync15, lstatSync as lstatSync5, realpathSync as realpathSync15, statSync as statSync11 } from "fs";
-import { isAbsolute, join as join28, normalize, sep as sep10 } from "path";
+import { existsSync as existsSync18, lstatSync as lstatSync4, realpathSync as realpathSync14, statSync as statSync11 } from "fs";
+import { isAbsolute as isAbsolute2, join as join30, normalize, sep as sep9 } from "path";
 var PROJECT_MODEL_SCHEMA = "loki.v10.project/1";
 var COMMAND_KINDS = ["test", "lint", "build", "start"];
 var isRec = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isStr = (v) => typeof v === "string" && v.trim() !== "";
 function safeRel(p) {
-  const n2 = normalize(p.trim()).split(sep10).join("/").replace(/\/$/, "");
-  if (n2 === "" || isAbsolute(n2) || n2 === ".." || n2.startsWith("../"))
+  const n2 = normalize(p.trim()).split(sep9).join("/").replace(/\/$/, "");
+  if (n2 === "" || isAbsolute2(n2) || n2 === ".." || n2.startsWith("../"))
     return null;
   return n2;
 }
 function insideRepo(repoDir, rel) {
   try {
-    const real2 = realpathSync15(join28(repoDir, rel));
-    const base = realpathSync15(repoDir);
-    return real2 === base || real2.startsWith(base + sep10);
+    const real2 = realpathSync14(join30(repoDir, rel));
+    const base = realpathSync14(repoDir);
+    return real2 === base || real2.startsWith(base + sep9);
   } catch {
     return false;
   }
@@ -17973,8 +18123,8 @@ function checkCitation(repoDir, raw2) {
   const rel = safeRel(raw2.replace(/:\d+(?:-\d+)?$/, ""));
   if (rel === null)
     return `citation "${raw2}" is not a repo-relative path`;
-  const abs = join28(repoDir, rel);
-  if (!existsSync15(abs) || !statSync11(abs).isFile() || !insideRepo(repoDir, rel))
+  const abs = join30(repoDir, rel);
+  if (!existsSync18(abs) || !statSync11(abs).isFile() || !insideRepo(repoDir, rel))
     return `citation "${raw2}" names a file that does not exist`;
   return null;
 }
@@ -17985,7 +18135,7 @@ function checkFingerprint(repoDir, raw2) {
   if (rel === null)
     return `fingerprint "${raw2}" is not a repo-relative path`;
   try {
-    if (!lstatSync5(join28(repoDir, rel)).isFile() || !insideRepo(repoDir, rel))
+    if (!lstatSync4(join30(repoDir, rel)).isFile() || !insideRepo(repoDir, rel))
       return `fingerprint "${raw2}" is not a regular file inside the repo`;
   } catch {
     return `fingerprint "${raw2}" names a file that does not exist`;
@@ -18013,8 +18163,8 @@ function checkDir(repoDir, v, where, errs) {
     errs.push(`${where}: must be a repo-relative directory ("." for the repo root)`);
     return ".";
   }
-  const abs = join28(repoDir, rel);
-  if (!existsSync15(abs) || !statSync11(abs).isDirectory() || !insideRepo(repoDir, rel))
+  const abs = join30(repoDir, rel);
+  if (!existsSync18(abs) || !statSync11(abs).isDirectory() || !insideRepo(repoDir, rel))
     errs.push(`${where}: directory "${rel}" does not exist`);
   return rel;
 }
@@ -18121,6 +18271,62 @@ var GATHER_CAPS = {
   maxTreeLines: 300,
   maxHashBytes: 16 * 1024 * 1024
 };
+var depthOf = (p) => p.split("/").length;
+function listShallow(repoDir) {
+  try {
+    const out2 = safeGit(repoDir, ["ls-files", "-z"], { maxBuffer: 256 * 1024 * 1024 });
+    return out2.split("\x00").filter((p) => p !== "").slice(0, GATHER_CAPS.maxListFiles).filter((p) => depthOf(p) <= GATHER_CAPS.maxDepth);
+  } catch {
+    return [];
+  }
+}
+function shallowDirs(repoDir) {
+  return [...new Set(listShallow(repoDir).map((p) => dirname9(p)))].sort();
+}
+var MODEL_REV = "model-rev:2";
+function computeKey(repoDir, fingerprintFiles, dirs, committedHash = null) {
+  const h = createHash7("sha256");
+  h.update(`${MODEL_REV}
+`);
+  if (committedHash !== null)
+    h.update(`committed:${committedHash}
+`);
+  for (const f of [...fingerprintFiles].sort()) {
+    h.update(`file:${f}
+`);
+    try {
+      if (checkFingerprint(repoDir, f) !== null)
+        h.update("invalid");
+      else {
+        const abs = join31(repoDir, f);
+        const size = lstatSync5(abs).size;
+        h.update(size <= GATHER_CAPS.maxHashBytes ? readFileSync22(abs) : `too-large:${size}`);
+      }
+    } catch {
+      h.update("missing");
+    }
+    h.update(`
+`);
+  }
+  for (const d of dirs)
+    h.update(`dir:${d}
+`);
+  return h.digest("hex");
+}
+function isGitTracked(repoDir, relPath) {
+  try {
+    const out2 = safeGit(repoDir, ["ls-files", "--error-unmatch", "--", relPath], { timeout: 1e4 });
+    return out2.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+function committedModelHash(raw2) {
+  if (typeof raw2 !== "object" || raw2 === null || Array.isArray(raw2))
+    return null;
+  const { key: _key, expiresAt: _exp, ...rest } = raw2;
+  return createHash7("sha256").update(JSON.stringify(rest)).digest("hex");
+}
 
 // ../../loki-ts/src/project_model/discover.ts
 function projectModelEnabled(env = process.env) {
@@ -18130,11 +18336,36 @@ var PROJECT_FILE = ".loki/project.json";
 var UNKNOWN_TTL_MS = 60 * 60 * 1000;
 function loadCached(repoDir, now2 = Date.now()) {
   try {
-    return parseCached(repoDir, JSON.parse(readFileSync20(join29(repoDir, PROJECT_FILE), "utf8")), now2);
+    return parseCached(repoDir, JSON.parse(readFileSync23(join32(repoDir, PROJECT_FILE), "utf8")), now2);
   } catch {
     return null;
   }
 }
+function loadCommitted(repoDir) {
+  if (!isGitTracked(repoDir, PROJECT_FILE))
+    return null;
+  const ignore = (why) => {
+    process.stderr.write(`loki: ignoring committed ${PROJECT_FILE}: ${why}; falling back to discovery
+`);
+    return null;
+  };
+  let raw2;
+  try {
+    raw2 = JSON.parse(readFileSync23(join32(repoDir, PROJECT_FILE), "utf8"));
+  } catch (e) {
+    return ignore(`unreadable JSON (${e instanceof Error ? e.message : String(e)})`);
+  }
+  const hash = committedModelHash(raw2);
+  if (hash === null)
+    return ignore("not a JSON object");
+  const r = raw2;
+  if (r["schema"] !== PROJECT_MODEL_SCHEMA || r["status"] !== "ok")
+    return ignore(`needs schema "${PROJECT_MODEL_SCHEMA}" and status "ok"`);
+  const v = validateAnswer(repoDir, raw2);
+  if (!v.ok)
+    return ignore(v.errors.slice(0, 3).join("; "));
+  return { model: { ...v.model, key: "" }, hash };
+}
 
 // ../../loki-ts/src/project_model/api.ts
 import { posix } from "path";
@@ -18201,48 +18432,1235 @@ function loadProjectApi(repoDir, env = process.env) {
 function isMultiRoot(api) {
   return !!api && api.known() && api.packages().some((p) => p.root !== ".");
 }
+function siteFor(api, repoDir, file) {
+  if (!isMultiRoot(api))
+    return null;
+  const pkg = api.packageOf(file);
+  const rel = api.relativeToRoot(file);
+  if (!pkg || pkg.root === "." || rel === null)
+    return null;
+  return { pkg, root: pkg.root, cwd: join33(repoDir, pkg.root), file: rel };
+}
+function groupByPackage(api, repoDir, files) {
+  const out2 = new Map;
+  for (const f of files) {
+    const s = siteFor(api, repoDir, f);
+    const root = s?.root ?? ".";
+    const g = out2.get(root) ?? { root, cwd: s?.cwd ?? repoDir, files: [], rel: [] };
+    g.files.push(f);
+    g.rel.push(s?.file ?? f);
+    out2.set(root, g);
+  }
+  return [...out2.values()];
+}
 
 // ../../loki-ts/src/project_model/scope.ts
 var apis = new WeakMap;
 var imports = new WeakMap;
 var dropped = new WeakMap;
+function scopedOutOf(map) {
+  return [...dropped.get(map) ?? []].sort();
+}
 
-// ../../loki-ts/src/engine10/testmap.ts
-var SKIP_DIRS = new Set([
-  ".git",
-  "node_modules",
-  "dist",
-  "build",
-  "target",
-  "coverage",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".tox",
-  ".pytest_cache",
-  ".loki",
-  ".next"
-]);
-var JS_TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
-var PY_TEST_RE = /^(test_.+|.+_test)\.py$/;
-var GO_TEST_RE = /_test\.go$/;
-function isTestFile(rel) {
-  const name = basename9(rel);
-  return JS_TEST_RE.test(name) || PY_TEST_RE.test(name) || GO_TEST_RE.test(name);
+// ../../loki-ts/src/engine10/stages/verify.ts
+import { existsSync as existsSync20, mkdtempSync as mkdtempSync5, realpathSync as realpathSync16, rmSync as rmSync8 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
+import { dirname as dirname10, isAbsolute as isAbsolute4, join as join38, relative as relative4 } from "path";
+
+// ../../loki-ts/src/e10ext/assert_delta.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { mkdtempSync as mkdtempSync3, readFileSync as readFileSync24, rmSync as rmSync6 } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join34 } from "path";
+import { basename as basename10 } from "path";
+var WEAKENED = { verdict: "weakened", changes: [] };
+var PY = String.raw`
+import ast, copy, io, json, re, sys, tokenize
+d = json.load(sys.stdin)
+bs, hs, task = d["base"], d["head"], d["task"]
+def out(v, it=()):
+    print(json.dumps({"verdict": v, "items": list(it)}))
+    sys.exit(0)
+if "\r" in bs or "\r" in hs or "\t" in bs or "\t" in hs:
+    out("weakened")
+bt, ht = ast.parse(bs), ast.parse(hs)
+# every byte outside a literal token (comments, blank lines, spacing, other code) must be identical
+def template(src):
+    lines = src.split("\n")
+    starts, o = [], 0
+    for ln in lines:
+        starts.append(o)
+        o += len(ln) + 1
+    spans = [(starts[t.start[0] - 1] + t.start[1], starts[t.end[0] - 1] + t.end[1])
+             for t in tokenize.generate_tokens(io.StringIO(src).readline) if t.type in (tokenize.STRING, tokenize.NUMBER)]
+    r, pos = [], 0
+    for a, b in spans:
+        r.append(src[pos:a] + "\0")
+        pos = b
+    return "".join(r) + src[pos:]
+if template(bs) != template(hs):
+    out("weakened")
+class Norm(ast.NodeTransformer):
+    def visit_Constant(self, n):
+        return ast.copy_location(ast.Constant(value="<" + type(n.value).__name__ + ">"), n)
+def norm(t):
+    return ast.dump(Norm().visit(copy.deepcopy(t)))
+# only what pytest collects: module-level test functions and methods of Test* classes without __init__
+def tests(t):
+    r = []
+    for n in t.body:
+        if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name.startswith("test"):
+            r.append(n)
+        elif isinstance(n, ast.ClassDef) and n.name.startswith("Test") \
+                and not any(isinstance(m, (ast.FunctionDef, ast.AsyncFunctionDef)) and m.name == "__init__" for m in n.body):
+            r += [m for m in n.body if isinstance(m, (ast.FunctionDef, ast.AsyncFunctionDef)) and m.name.startswith("test")]
+    return r
+def direct(f):
+    return [a for a in f.body if isinstance(a, ast.Assert)]
+def tables(t):
+    return [n.args[1] for n in ast.walk(t) if isinstance(n, ast.Call) and getattr(n.func, "attr", "") == "parametrize"
+            and len(n.args) > 1 and isinstance(n.args[1], (ast.List, ast.Tuple))]
+def stripped(t):
+    c = copy.deepcopy(t)
+    for tb in tables(c):
+        tb.elts = []
+    return c
+def consts(t):
+    return [n for n in ast.walk(t) if isinstance(n, ast.Constant)]
+def shadowed(t):
+    for scope in [t] + [n for n in t.body if isinstance(n, ast.ClassDef)]:
+        names = [n.name for n in scope.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name.startswith("test")]
+        if len(names) != len(set(names)):
+            return True
+    return False
+if shadowed(bt) or shadowed(ht):
+    out("weakened")
+sb, sh = stripped(bt), stripped(ht)
+if not tests(ht) or norm(sb) != norm(sh):
+    out("weakened")
+for t in (bt, ht):
+    if any(isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "round" for n in ast.walk(t)):
+        out("weakened")
+tb, th = tables(bt), tables(ht)
+if any(len(x.elts) != len(y.elts) for x, y in zip(tb, th)):
+    out("weakened")
+if any(norm(r) != norm(q) for x, y in zip(tb, th) for r, q in zip(x.elts, y.elts)):
+    out("weakened")
+owner = {}
+for f in tests(sh):
+    for n in ast.walk(f):
+        owner[id(n)] = f
+pairs = [(b, h, owner.get(id(h))) for b, h in zip(consts(sb), consts(sh))]
+fh = {}
+for f in tests(ht):
+    for t in tables(f):
+        fh[id(t)] = f
+for x, y in zip(tb, th):
+    for r, q in zip(x.elts, y.elts):
+        pairs += [(b, h, fh.get(id(y))) for b, h in zip(consts(r), consts(q))]
+def eqs(f):
+    return [a.test for a in direct(f) if isinstance(a.test, ast.Compare) and len(a.test.ops) == 1 and isinstance(a.test.ops[0], ast.Eq)]
+def dups(t):
+    r = {}
+    for f in tests(t):
+        ds = [ast.dump(a) for a in direct(f)]
+        r[f.name] = len(ds) - len(set(ds))
+    return r
+dh, db = dups(ht), dups(bt)
+ok = not any(v > db.get(k, 0) for k, v in dh.items())
+# expected side = the right operand of a direct "assert X == Y"
+exp = set()
+for f in tests(sh):
+    exp |= {id(c.comparators[0]) for c in eqs(f) if isinstance(c.comparators[0], ast.Constant)}
+for f in tests(ht):
+    rights = {id(c.comparators[0]) for c in eqs(f) if isinstance(c.comparators[0], ast.Name)}
+    for c in f.decorator_list:
+        if isinstance(c, ast.Call) and getattr(c.func, "attr", "") == "parametrize" and len(c.args) > 1 \
+                and isinstance(c.args[0], ast.Constant) and isinstance(c.args[0].value, str) and isinstance(c.args[1], (ast.List, ast.Tuple)):
+            cols = [x.strip() for x in c.args[0].value.split(",")]
+            # a column counts only if every use of its name in the body is the right operand of a direct eq assert
+            if any(kw.arg == "indirect" for kw in c.keywords):
+                continue
+            deco = {id(m) for dd in f.decorator_list for m in ast.walk(dd)}
+            uses = {k: [n for n in ast.walk(f) if isinstance(n, ast.Name) and n.id == k and id(n) not in deco] for k in cols}
+            # the column must be read at least once, and only as the right operand of a direct eq assert
+            solo = {k for k, u in uses.items() if u and all(id(n) in rights for n in u)}
+            for r in c.args[1].elts:
+                for i, e in enumerate(r.elts if isinstance(r, (ast.Tuple, ast.List)) else [r]):
+                    if isinstance(e, ast.Constant) and i < len(cols) and cols[i] in solo:
+                        exp.add(id(e))
+def callees(f):
+    r = set()
+    for c in eqs(f):
+        for n in ast.walk(c.left):
+            if isinstance(n, ast.Call):
+                k = n.func.id if isinstance(n.func, ast.Name) else getattr(n.func, "attr", "")
+                if k:
+                    r.add(k)
+    return r
+def generic(v):
+    return v is None or isinstance(v, (bool, bytes)) or (isinstance(v, str) and len(v) <= 3) \
+        or (isinstance(v, (int, float)) and abs(v) < 10)
+def in_task(v, f):
+    task0 = d["task"]
+    t = v if isinstance(v, str) else repr(v)
+    if t == "":
+        return False
+    # bounded by whitespace, string ends or ,;:()[]{}"' only; never glued to - + or a digit group separator
+    tok = r"(?<![^\s,;:()\[\]{}\"'])(?<!\d,)" + re.escape(t) + r"(?:(?=[\s,;:()\[\]{}\"']|$)(?!,\d)|\.(?=\s|$))"
+    task = re.sub(r"(?<=\d),(?=\d{3}\b)", "", task0)
+    if not generic(v):
+        return re.search(tok, task) is not None
+    # a generic value counts only right next to the identifier the test calls
+    return any(re.search(r"\b" + re.escape(k) + r"\b[^\n]{0,40}?" + tok, task) for k in (callees(f) if f else ()))
+items = []
+for b, h, f in pairs:
+    if (type(b.value), repr(b.value)) != (type(h.value), repr(h.value)):
+        hit = in_task(h.value, f)
+        ok = ok and id(h) in exp and hit
+        items.append({"line": h.lineno, "old": repr(b.value), "new": repr(h.value), "inTask": hit, "matched": "new"})
+out("value-change" if ok and items else "weakened", items if ok else [])
+`;
+var okStr = (v) => typeof v === "string" && v.length <= 200 && !/[\x00-\x1f\x7f]/.test(v);
+function classifyAssertDelta(inp) {
+  const f = basename10(inp.path);
+  if (!/^(test_.*|.*_test)\.py$/.test(f))
+    return WEAKENED;
+  if (inp.headCounts.run !== inp.baseCounts.run || inp.headCounts.skipped !== inp.baseCounts.skipped)
+    return WEAKENED;
+  let cwd = "";
+  try {
+    cwd = mkdtempSync3(join34(tmpdir4(), "loki-ad-"));
+    const raw2 = execFileSync5("python3", ["-I", "-c", PY], {
+      input: JSON.stringify({ path: inp.path, base: inp.base, head: inp.head, task: inp.task }),
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "ignore"],
+      encoding: "utf8",
+      timeout: 20000
+    });
+    const r = JSON.parse(raw2);
+    if (r.verdict !== "value-change" || !Array.isArray(r.items) || r.items.length === 0)
+      return WEAKENED;
+    const items = [];
+    for (const i of r.items) {
+      if (!i || typeof i !== "object" || !Number.isInteger(i["line"]) || i["line"] < 1 || !okStr(i["old"]) || !okStr(i["new"]) || i["inTask"] !== true || i["matched"] !== "new")
+        return WEAKENED;
+      items.push({ line: i["line"], old: i["old"], new: i["new"], matched: "new" });
+    }
+    return { verdict: "value-change", changes: items.map((i) => `${inp.path}:${i.line} ${i.old} -> ${i.new}`), items };
+  } catch {
+    return WEAKENED;
+  } finally {
+    if (cwd)
+      rmSync6(cwd, { recursive: true, force: true });
+  }
+}
+function assertDeltaNotes(repoDir, baseSha, headRef, path, task, baseCounts, headCounts) {
+  if (!baseCounts || !headCounts)
+    return null;
+  try {
+    const show = (ref) => safeGit(repoDir, ["show", `${ref}:${path}`]);
+    const head = headRef ? show(headRef) : readFileSync24(join34(repoDir, path), "utf8");
+    const r = classifyTestEdit(path, show(baseSha), head, task, baseCounts, headCounts);
+    return r[0]?.kind === "literal-only" ? r.map((e) => `assertion value changed (not shown to be required by the task): ${e.file}:${e.line} ${e.old} -> ${e.new}`) : null;
+  } catch {
+    return null;
+  }
+}
+function classifyTestEdit(file, oldText, newText, taskText, baseCounts, headCounts) {
+  const weak = [{ kind: "weakened", file, line: 0, old: "", new: "", inTask: false }];
+  const r = classifyAssertDelta({ path: file, base: oldText, head: newText, task: taskText, baseCounts, headCounts });
+  if (r.verdict !== "value-change" || !r.items?.length)
+    return weak;
+  return r.items.map((i) => ({ kind: "literal-only", file, line: i.line, old: i.old, new: i.new, inTask: true }));
+}
+
+// ../../loki-ts/src/engine10/failures.ts
+var ID_LINE = /^(?:(?:FAILED|ERROR)\s+(\S+::\S*)(?:\s.*)?|\u25cf\s+(?!Console|Test suite failed)(.+)|not ok \d+ - (.+?)(?:\s+#.*)?|\u2716\s+(?!failing tests:)(.+?)(?:\s+\([\d.]+ms\))?|(?:FAIL|\u00d7)\s+(.+))$/;
+function failCount(out2) {
+  const n2 = (s, re) => +(s.match(re)?.[1] ?? 0);
+  const l = out2.split(`
+`).reverse().map((x) => x.trim()).find((x) => /^(?:=+ )?\d+ \w+.* in [\d.]+s|^Tests?:?\s+\d/.test(x)), m = /^(?:#|\u2139) fail (\d+)$/m.exec(out2);
+  return l ? n2(l, /(\d+) failed/) + n2(l, /(\d+) errors?/) : m ? +m[1] : null;
+}
+function failIds(output) {
+  const ids = [...new Set(output.split(`
+`).map((l) => ID_LINE.exec(l.trim())).flatMap((m) => m ? [(m.slice(1).find(Boolean) ?? "").trim()] : []).filter(Boolean))];
+  const c = failCount(output);
+  return c && ids.length >= c ? ids : [];
+}
+
+// ../../loki-ts/src/runner/load_owner.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { mkdtempSync as mkdtempSync4, realpathSync as realpathSync15, rmSync as rmSync7 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { basename as basename11, extname, join as join35 } from "path";
+
+// ../../loki-ts/src/runner/runner_errors.ts
+function hasRealTestFailure(out2) {
+  return /^\s*Tests:?\s+.*\b[1-9]\d* failed\b/m.test(out2) || /^(?:=+ )?.*\b[1-9]\d* failed\b.* in [\d.]+s/m.test(out2) || /^FAILED \S+::/m.test(out2) || /^(?:#|\u2139) fail [1-9]/m.test(out2) || /^\s*[1-9]\d*\s+fail\s*$/m.test(out2) || /^\s*(?:FAIL|\u00D7)\s+\S.*\s>\s/m.test(out2) || /\bAssertionError\b/.test(out2);
+}
+var LOAD_PATTERNS = [
+  [/Failed Suites\s+[1-9]/, "test suite failed to load"],
+  [/Test suite failed to run/, "test suite failed to run"],
+  [/Failed to load (?:url|config)|failed to load config|Failed to resolve (?:import|entry)/i, "runner config or import could not be loaded"],
+  [/^\s*(?:\w*Error: )?Cannot find (?:module|package) '[^']+'/m, "module not found while loading tests"],
+  [/ERR_MODULE_NOT_FOUND/, "module not found while loading tests"],
+  [/Interrupted: \d+ errors? during collection/, "collection error"],
+  [/^_+ ERROR collecting /m, "collection error"],
+  [/ImportError while importing test module/, "test module import error"],
+  [/^ERROR: (?:file or directory not found|not found:)/m, "test path not found by the runner"],
+  [/No test files found, exiting with code [1-9]/, "runner found no test files (wrong cwd or path)"],
+  [/\[setup failed\]|cannot find package|no required module provides package/, "go package could not be set up"],
+  [/could not determine executable to run/i, "test runner executable not found"],
+  [/^(?:\S+: )?(?:line \d+: )?[\w.-]+: command not found$/m, "test runner executable not found"]
+];
+function firstLoadLine(out2) {
+  const lines = out2.split(`
+`).map((l2) => l2.trim()).filter(Boolean);
+  const l = lines.find((x) => /^(?:E\s+)?(?:Error|\w*Error|ERROR|Failed|FAIL)\b|Cannot find|Interrupted:|No test files found/.test(x)) ?? lines[0] ?? "";
+  return l.replace(/\s+/g, " ").slice(0, 160);
+}
+function classifyRunnerOutput(out2) {
+  if (!hasRealTestFailure(out2)) {
+    for (const [re, why] of LOAD_PATTERNS) {
+      if (re.test(out2))
+        return { kind: "load_error", owner: "harness", reason: `runner could not load: ${why}: ${firstLoadLine(out2)}` };
+    }
+  }
+  return { kind: "test_failure", owner: "code" };
+}
+
+// ../../loki-ts/src/runner/load_owner.ts
+var esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var suffixes = (segs, min) => segs.map((_, k) => segs.slice(k).join("/")).filter((x) => x.split("/").length >= min);
+var bounded = (out2, tok, tail) => new RegExp(`(?<![\\w.-])${esc(tok)}${tail}`).test(out2);
+function changedFilesNamed(out2, repoDir, changed) {
+  return changed.filter((f) => {
+    if (out2.includes(f) || out2.includes(join35(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)))
+      return true;
+    const stem = basename11(f, extname(f));
+    if (stem.length < 2 || stem === "index" || stem === "__init__")
+      return false;
+    return new RegExp(`(?<![\\w-])${esc(stem)}(?![\\w-])`).test(out2);
+  });
+}
+function loadSignature(out2, roots) {
+  let o = out2;
+  for (const r of roots.flatMap((x) => {
+    try {
+      return [x, realpathSync15(x)];
+    } catch {
+      return [x];
+    }
+  }).sort((a, b) => b.length - a.length))
+    o = o.split(r).join("<repo>");
+  const keys = new Set;
+  for (const m of o.matchAll(/Cannot find (?:module|package) '([^']+)'/g))
+    keys.add(`mod:${m[1]}`);
+  for (const m of o.matchAll(/([\w.-]+): command not found/g))
+    keys.add(`cmd:${m[1]}`);
+  return { keys, reason: (classifyRunnerOutput(o).reason ?? "").replace(/:\d+(?::\d+)?/g, "") };
+}
+function sameLoadError(head, base, headRoots, baseRoots) {
+  const h = loadSignature(head, headRoots), b = loadSignature(base, baseRoots);
+  if (b.keys.size)
+    return h.keys.size > 0 && [...b.keys].every((k) => h.keys.has(k));
+  return h.keys.size === 0 && h.reason === b.reason;
+}
+function killTree(pid) {
+  const all = [pid];
+  for (let k = 0;k < all.length; k++) {
+    const kids = spawnSync2("pgrep", ["-P", String(all[k])], { encoding: "utf8", env: process.env }).stdout.split(/\s+/).filter(Boolean).map(Number);
+    all.push(...kids.filter((x) => Number.isInteger(x) && !all.includes(x)));
+  }
+  try {
+    if (Number.isInteger(pid) && pid > 1)
+      process.kill(-pid, "SIGKILL");
+  } catch {}
+  for (const p of all.reverse()) {
+    try {
+      process.kill(p, "SIGKILL");
+    } catch {}
+  }
+}
+async function runOnBase(i, dir) {
+  const sub = (s) => s.split(i.repoDir).join(dir);
+  const stop = AbortSignal.any([i.signal, AbortSignal.timeout(i.timeoutMs ?? 60000)]);
+  try {
+    const proc = Bun.spawn([sub(i.cmd), ...i.args.map(sub)], {
+      cwd: sub(i.cwd ?? i.repoDir),
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      detached: true,
+      env: { ...process.env, ...i.env ?? {} }
+    });
+    let tail = "";
+    const rs = [proc.stdout, proc.stderr].map((x) => x.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 cut = new Promise((res) => {
+      if (stop.aborted)
+        res(null);
+      else
+        stop.addEventListener("abort", () => res(null), { once: true });
+    });
+    const code = await Promise.race([proc.exited, cut]);
+    if (code === null) {
+      killTree(proc.pid);
+      return null;
+    }
+    await Promise.race([Promise.all(pumps), new Promise((r) => setTimeout(r, 300))]);
+    rs.forEach((r) => r.cancel().catch(() => {}));
+    return stop.aborted || code === 0 ? null : tail;
+  } catch {
+    return null;
+  }
+}
+function changedSince(repoDir, baseSha) {
+  const g = (a) => safeGit(repoDir, a).split(`
+`).map((l) => l.trim()).filter(Boolean);
+  return [...new Set([...g(["diff", "--name-only", baseSha]), ...g(["ls-files", "--others", "--exclude-standard"])])].filter((f) => !f.startsWith(".loki/"));
+}
+async function loadErrorIsHarnessOwned(i) {
+  if (i.protect || !i.baseSha || i.signal.aborted)
+    return false;
+  let changed;
+  try {
+    changed = changedSince(i.repoDir, i.baseSha);
+  } catch {
+    return false;
+  }
+  if (changedFilesNamed(i.out, i.repoDir, changed).length > 0)
+    return false;
+  if (i.args.some((a) => changed.includes(a.replace(/^\.\//, ""))))
+    return false;
+  const dir = mkdtempSync4(join35(tmpdir5(), "e10-loadown-"));
+  const git2 = (args) => {
+    safeGit(i.repoDir, args, { stdio: "ignore" });
+  };
+  try {
+    git2(["worktree", "add", "--detach", dir, i.baseSha]);
+    const base = await runOnBase(i, dir);
+    return base !== null && classifyRunnerOutput(base).kind === "load_error" && sameLoadError(i.out, base, [i.repoDir, ...i.cwd ? [i.cwd] : []], [dir]);
+  } catch {
+    return false;
+  } finally {
+    try {
+      git2(["worktree", "remove", "--force", dir]);
+    } catch {}
+    rmSync7(dir, { recursive: true, force: true });
+    try {
+      git2(["worktree", "prune"]);
+    } catch {}
+  }
+}
+async function harnessLoadReason(i) {
+  const c = classifyRunnerOutput(i.out);
+  return c.kind === "load_error" && await loadErrorIsHarnessOwned(i) ? c.reason : undefined;
+}
+
+// ../../loki-ts/src/engine10/testmap.ts
+import { basename as basename12, extname as extname2, join as join36, relative as relative2, sep as sep10 } from "path";
+var SKIP_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "target",
+  "coverage",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".tox",
+  ".pytest_cache",
+  ".loki",
+  ".next"
+]);
+var JS_TEST_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+var PY_TEST_RE = /^(test_.+|.+_test)\.py$/;
+var GO_TEST_RE = /_test\.go$/;
+function isTestFile(rel) {
+  const name = basename12(rel);
+  return JS_TEST_RE.test(name) || PY_TEST_RE.test(name) || GO_TEST_RE.test(name);
+}
+
+// ../../loki-ts/src/util/check_result.ts
+import { basename as basename13 } from "path";
+var NO_TESTS_REASON = "no tests executed";
+var 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)";
+var UNCONFIRMED_REASON = "test count could not be confirmed";
+var FAIL_EVIDENCE = /\[(?:build|setup) failed\]|^--- FAIL|^[\w./-]+\.go:\d+:\d+: \S|\b[1-9]\d* (?:failed|errors?)\b/m;
+var GO_FAIL_EVIDENCE = /^FAIL\t\S+\t[\d.]+s$|^panic: /m;
+var UNMEASURED_REASON = "executed count unmeasured (Loki could not parse the runner summary, harness-owned)";
+function ran(raw2, path, ok) {
+  const out2 = stripAnsi(raw2);
+  const n2 = (s, re) => +(s.match(re)?.[1] ?? 0);
+  const blk = out2.trimEnd().match(/(?:^|\n)((?:(?:#|\u2139) \w+ [\d.]+(?:\n|$)){5,})$/)?.[1];
+  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 || basename13(nm) === basename13(path)) ? 0 : c;
+  }
+  const cg = cargoTrailer(out2);
+  if (cg.length)
+    return cg.reduce((t, l2) => t + n2(l2, /(\d+) passed/) + n2(l2, /(\d+) failed/), 0);
+  const g = goCount(out2, ok);
+  if (g !== undefined)
+    return g;
+  const tail = tailLines(out2);
+  const l = tail.filter((x) => /^(?:=+ )?(?:\d+ \w+.*|no tests ran) in [\d.]+s|^\s*Tests?:?\s+\d|^No tests found/.test(x) && (!/^\s*Tests?:?\s+\d/.test(x) || tail.some((y) => /^\s*Test (?:Files|Suites):?\s+\d/.test(y)))).pop();
+  if (!l)
+    return null;
+  return /^(?:=+ )?no tests (?:ran|found)|^No tests found|skipped/i.test(l) || /\d+ (?:passed|failed|errors?)/.test(l) ? n2(l, /(\d+) passed/) + n2(l, /(\d+) failed/) + n2(l, /(\d+) errors?/) : null;
+}
+var stripAnsi = (s) => s.replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "").replace(/(?:\u001b\[|\u009b)[0-9;?]*[ -\/]*[@-~]/g, "").replace(/\r\n?/g, `
+`);
+var tailLines = (out2) => out2.split(`
+`).filter((x) => x.trim()).slice(-12);
+function cargoTrailer(out2) {
+  const ls = out2.split(`
+`).filter((x) => x.trim());
+  while (ls.length && /^error: /.test(ls[ls.length - 1]))
+    ls.pop();
+  const segs = [];
+  for (const l of ls) {
+    if (/^running \d+ tests?\b/.test(l))
+      segs.push([]);
+    else if (segs.length && !/^\s*(?:Running |Doc-tests |Doctest)/.test(l))
+      segs[segs.length - 1].push(l);
+  }
+  const lastOf = (g) => g[g.length - 1]?.startsWith("test result: ") ? g[g.length - 1] : undefined;
+  if (!segs.length) {
+    const g = [];
+    for (let k = ls.length - 1;k >= 0 && ls[k].startsWith("test result: "); k--)
+      g.push(ls[k]);
+    return g;
+  }
+  if (!lastOf(segs[segs.length - 1]))
+    return [];
+  return segs.flatMap((g) => lastOf(g) ?? []);
+}
+function bunCount(out2) {
+  const ls = out2.split(`
+`).filter((x) => x.trim());
+  if (!/^Ran \d+ tests? across \d+ files?\./.test(ls[ls.length - 1] ?? ""))
+    return null;
+  const blk = ls.slice(-9, -1);
+  const last = (k) => +(blk.map((x) => x.match(new RegExp(`^\\s*(\\d+) ${k}\\s*$`))?.[1]).filter(Boolean).pop() ?? 0);
+  return last("pass") + last("fail");
+}
+function unittestCount(out2, ok) {
+  const ls = out2.split(`
+`).filter((x) => x.trim()), v = ls[ls.length - 1] ?? "", r = ls[ls.length - 2]?.match(/^Ran (\d+) tests? in [\d.]+s$/);
+  if (!r || !/^(?:OK|FAILED)\b/.test(v))
+    return null;
+  if (ls.filter((x) => /^Ran \d+ tests? in [\d.]+s$/.test(x)).length > 1)
+    return null;
+  if (ok === true && v.startsWith("FAILED") || ok === false && v.startsWith("OK"))
+    return null;
+  return Math.max(0, +r[1] - +(v.match(/skipped=(\d+)/)?.[1] ?? 0) - +(v.match(/expected failures=(\d+)/)?.[1] ?? 0));
+}
+var GO_PKG_RE = /^(?:ok|FAIL|\?)\s+\S+\s+(?:\(cached\)|[\d.]+s\b|\[(?:no test files|build failed|setup failed)\])/;
+function goCount(out2, ok) {
+  const lines = out2.split(`
+`);
+  if (!lines.some((x) => GO_PKG_RE.test(x)))
+    return;
+  const last = new Map, seen = new Set, skip = new Set, failPkg = ok !== true && lines.some((x) => /^FAIL\s+\S+\s+[\d.]+s\b/.test(x));
+  for (const x of lines) {
+    const r = x.match(/^=== RUN\s+(\S+)/), m = x.match(/^--- (PASS|FAIL|SKIP): (\S+)/);
+    if (r)
+      seen.add(r[1]);
+    else if (m && (seen.has(m[2]) || m[1] === "FAIL" && failPkg)) {
+      last.set(m[2], m[1]);
+      if (m[1] === "SKIP")
+        skip.add(m[2]);
+    }
+  }
+  for (const k of skip)
+    last.set(k, "SKIP");
+  if (ok === true && [...last.values()].includes("FAIL"))
+    return null;
+  const t = [...last.values()].filter((v) => v !== "SKIP").length;
+  if (t > 0)
+    return t;
+  if (lines.some((x) => /^(?:=== RUN|PASS$|FAIL$|testing: warning: no tests to run)/.test(x)))
+    return 0;
+  return lines.filter((x) => GO_PKG_RE.test(x)).every((x) => /\[no tests? (?:files|to run)\]/.test(x)) ? 0 : null;
+}
+function goRunner(cmd, args) {
+  const segs = args ? [[cmd, ...args]] : cmd.split(/&&|\|\||[;|\n]/).map((x) => x.trim().split(/\s+/).filter(Boolean));
+  for (const t0 of segs) {
+    const t = t0.map((x) => x.replace(/^["']|["']$/g, ""));
+    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(basename13(x)))
+        continue;
+      if (/^-/.test(x) && k > 0 && basename13(t[k - 1]) === "env") {
+        if (x === "-u" || x === "-C" || x === "-S")
+          k++;
+        continue;
+      }
+      break;
+    }
+    if (t[k] !== undefined && basename13(t[k]) === "go")
+      return { runner: "go" };
+  }
+  return {};
+}
+function goJson(out2) {
+  let any = false, failed = false;
+  for (const x of out2.split(`
+`)) {
+    if (!x.trim() || /^go: /.test(x))
+      continue;
+    let e;
+    try {
+      e = JSON.parse(x);
+    } catch {
+      return null;
+    }
+    if (!e || typeof e !== "object" || typeof e.Action !== "string")
+      return null;
+    any = true;
+    if (e.Action === "fail")
+      failed = true;
+  }
+  return any ? { failed } : null;
+}
+function skipped(raw2) {
+  return stripAnsi(raw2).split(`
+`).filter((l) => /^(?:=+ )?\d+ \w+.* in [\d.]+s|^\s*Tests?:?\s+\d|^(?:#|\u2139) skipped \d/.test(l.trim())).reduce((t, l) => t + [...l.matchAll(/(\d+) (?:skipped|deselected|xfailed)|skipped (\d+)/g)].reduce((u, m) => u + +(m[1] ?? m[2]), 0), 0);
+}
+function testCount(raw2, path, ok) {
+  const out2 = stripAnsi(raw2);
+  const bu = bunCount(out2), ut = unittestCount(out2, ok);
+  if (bu !== null)
+    return bu;
+  if (ut !== null)
+    return ut;
+  if (/^\s*(?:Test Files\s+0\b|No test files found)/m.test(out2) && !/^\s*Tests?\s+\d/m.test(out2))
+    return 0;
+  const r = ran(out2, path, ok);
+  if (r !== null)
+    return r;
+  const tl = tailLines(out2);
+  const pw = tl.filter((x) => /^\s*\d+ (?:passed|failed|flaky)\b/.test(x));
+  if (pw.length && tl.some((x) => /^\s*\d+ passed \([\d.]+m?s\)/.test(x) || /^\s*\d+ failed$/.test(x)))
+    return pw.reduce((t, x) => t + +x.trim().split(" ")[0], 0);
+  const lastNum = (re) => {
+    const m = [...out2.matchAll(re)].pop();
+    return m ? +m[1] : null;
+  };
+  const mp = lastNum(/^\s*(\d+) passing\b/gm), mf = lastNum(/^\s*(\d+) failing\b/gm);
+  if (mp !== null || mf !== null)
+    return (mp ?? 0) + (mf ?? 0);
+  return null;
+}
+function classifyCheck(i) {
+  if (i.missing)
+    return { result: "not_run", reason: "tool not found on PATH" };
+  if (i.cut)
+    return { result: "not_run", reason: "timed out or aborted" };
+  if (i.kind === "static")
+    return { result: i.ok ? "pass" : "fail" };
+  const text2 = stripAnsi(i.out);
+  if (i.runner === "go") {
+    if (i.ok)
+      return { result: "not_run", reason: GO_EXIT0_REASON };
+    const j = goJson(text2);
+    if (j)
+      return j.failed ? { result: "fail" } : { result: "not_run", reason: UNCONFIRMED_REASON };
+    return FAIL_EVIDENCE.test(text2) || GO_FAIL_EVIDENCE.test(text2) ? { result: "fail" } : { result: "not_run", reason: UNCONFIRMED_REASON };
+  }
+  const n2 = testCount(i.out, i.path, i.ok);
+  if (!i.ok && FAIL_EVIDENCE.test(text2))
+    return { result: "fail", ...n2 !== null ? { n: n2 } : {} };
+  if (n2 === 0)
+    return { result: "not_run", n: 0, reason: `${NO_TESTS_REASON} (ran 0 tests, empty or all skipped)` };
+  if (!i.ok)
+    return { result: "fail", ...n2 !== null ? { n: n2 } : {} };
+  if (n2 === null)
+    return { result: "not_run", reason: UNMEASURED_REASON };
+  return { result: "pass", n: n2 };
+}
+var isExecutedProof = (c) => c.result === "pass" && typeof c.n === "number" && c.n > 0;
+var hasExecutedProof = (checks) => checks.some(isExecutedProof);
+
+// ../../loki-ts/src/util/wall_owned.ts
+import { isAbsolute as isAbsolute3, join as join37, relative as relative3 } from "path";
+var WALL_COMPILE_REASON = "wall test did not compile under the package config";
+var ANSI2 = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+function failingLocations(raw2, cwd, repoDir) {
+  const out2 = raw2.replace(ANSI2, "").replace(/\r\n?/g, `
+`), files = new Set;
+  let located = 0, errors2 = 0, header = null;
+  for (const line2 of out2.split(`
+`)) {
+    const m = /^(.+?)\(\d+,\d+\): error TS\d+:/.exec(line2) ?? /^(.+?):\d+:\d+ - error TS\d+:/.exec(line2) ?? /^(.+?):\d+:\d+: .*\berror\b/.exec(line2);
+    if (m) {
+      files.add(m[1]);
+      located++;
+      errors2++;
+      continue;
+    }
+    if (/\berror TS\d+:/.test(line2)) {
+      errors2++;
+      continue;
+    }
+    if (/^\S/.test(line2) && /^[^\s:]+\.[cm]?[jt]sx?$/.test(line2.trim())) {
+      header = line2.trim();
+      continue;
+    }
+    if (/^\s+\d+:\d+\s+error\b/.test(line2)) {
+      errors2++;
+      if (header) {
+        files.add(header);
+        located++;
+      }
+    }
+  }
+  if (errors2 === 0 || located !== errors2)
+    return null;
+  return [...files].map((f) => relative3(repoDir, isAbsolute3(f) ? f : join37(cwd, f)));
+}
+function wallOwnedFailure(raw2, cwd, repoDir, wall) {
+  const locs = failingLocations(raw2, cwd, repoDir);
+  return !!locs && locs.length > 0 && locs.every((l) => wall.has(l));
+}
+
+// ../../loki-ts/src/engine10/stages/verify.ts
+var CHECK_TIMEOUT_MS = 60000;
+function resolveTool(repoDir, bin, fallback, lastResort = fallback) {
+  const inRepo = (p) => {
+    try {
+      const r = relative4(realpathSync16(repoDir), realpathSync16(p));
+      return r !== "" && !r.startsWith("..") && !isAbsolute4(r);
+    } catch {
+      return false;
+    }
+  };
+  const venvEnv = process.env["VIRTUAL_ENV"];
+  const project = [join38(repoDir, ".venv", "bin", bin), join38(repoDir, "venv", "bin", bin), ...venvEnv && inRepo(venvEnv) ? [join38(venvEnv, "bin", bin)] : []].find(existsSync20);
+  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", `./${dirname10(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 ?? "." };
+}
+var dedupeTests = (tests) => [...new Map(tests.map((t) => [`${t.runner}:${t.path}`, t])).values()];
+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 CODE_EXT = /\.(?:[cm]?[jt]sx?|py|go)$/;
+var CFG_ALWAYS = /(^|\/)(conftest\.py|\.?pytest\.(?:ini|toml)|tox\.ini|jest\.config\.[\w.]+|vitest\.config\.[\w.]+|\.mocharc[\w.]*)$/;
+var CFG_SHARED = /(^|\/)(setup\.cfg|pyproject\.toml|package\.json)$/;
+var CFG_LINE = /^[+-].*(pytest|jest|mocha|vitest|"test"\s*:|addopts|testpaths)/im;
+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 ? { ...process.env, PATH: opts.path } : process.env
+  });
+  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 ? "" : 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;
+  const one = async (a) => {
+    let c2 = classifyCheck({ kind, ok: a.ok, cut: a.cut, missing: a.missing, out: a.out, ...goRunner(cmd, args), path: /\.[cm]?[jt]s$/.test(args[args.length - 1] ?? "") ? args[args.length - 1] : undefined });
+    const lr = kind === "test" && !a.ok && !a.cut && !a.missing ? await harnessLoadReason({ repoDir: ctx.repoDir, baseSha: ctx.baseSha, out: a.out, cmd, args, signal, cwd, protect: opts.protect, ...opts.path ? { env: { PATH: opts.path } } : {} }) : undefined;
+    if (lr)
+      c2 = { result: "not_run", reason: lr, owner: "harness" };
+    if (!lr && kind === "static" && !a.ok && !a.cut && !a.missing && opts.wall?.size && wallOwnedFailure(a.out, cwd, ctx.repoDir, opts.wall))
+      c2 = { result: "not_run", reason: WALL_COMPILE_REASON, owner: "harness" };
+    const reason2 = a.missing ? `${cmd} not found on PATH` : a.cut ? signal.aborted ? "aborted" : `timed out after ${(opts.timeoutMs ?? CHECK_TIMEOUT_MS) / 1000}s` : c2.reason;
+    return { ...c2, ...reason2 ? { reason: reason2 } : {} };
+  };
+  let attempt = await runOnce(cmd, args, cwd, signal, opts);
+  let c = await one(attempt);
+  let result = c.result;
+  if (c.result === "fail") {
+    attempt = await runOnce(cmd, args, cwd, signal, opts);
+    c = await one(attempt);
+    result = c.result === "not_run" ? "not_run" : c.result === "pass" ? "flaky" : "fail";
+  }
+  const reason = c.reason;
+  const check = { name, cmd: cmdStr, result, duration_s: (Date.now() - started) / 1000, ...result === "fail" ? { first_error: firstError(attempt.out), ids: failIds(attempt.out) } : result === "pass" && kind === "test" ? { n: c.n ?? 0, sk: skipped(attempt.out) } : {}, ...reason ? { reason } : {}, ...c.owner ? { owner: "harness" } : {}, ...opts.interpreter ? { interpreter: opts.interpreter } : {} };
+  checks.push(check);
+  ctx.emit("test.result", "verify", { ...check });
+  return check;
+}
+async function subtractBase(ctx, api, checks, tests, changed, wall, rel, signal) {
+  const out2 = { ids: [], names: [], weak: [], cnt: {} };
+  const pairs = checks.flatMap((c) => {
+    const t = tests.find((x) => `${x.runner}:${x.path}` === c.name);
+    return t ? [{ c, t }] : [];
+  });
+  const un = pairs.filter(({ t }) => !changed.includes(t.path));
+  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 = mkdtempSync5(join38(tmpdir6(), "e10-base-"));
+  const git2 = (args) => {
+    safeGit(ctx.repoDir, args, { stdio: "ignore", repoDrivers: true });
+  };
+  try {
+    git2(["-c", "core.hooksPath=/dev/null", "worktree", "add", "--detach", dir, ctx.baseSha]);
+    const base = new Map;
+    for (const { c, t } of new Set([...un, ...sus])) {
+      const bc = commandFor(t, dir, api), b = await runOnce(bc.cmd, bc.args, bc.cwd, signal, {});
+      base.set(c, { red: !b.ok && !b.cut ? failIds(b.out) : [], n: ran(b.out) ?? ["pass", "fail"].reduce((t2, k) => t2 + +([...b.out.matchAll(new RegExp(`^(?:#|\\u2139) ${k} (\\d+)$`, "gm"))].pop()?.[1] ?? 0), 0), sk: skipped(b.out) });
+    }
+    out2.weak = sus.filter(({ c }) => (c.sk ?? 0) > base.get(c).sk || (c.n ?? 0) < base.get(c).n).map(({ c }) => c.name);
+    for (const { c } of sus)
+      out2.cnt[c.name] = { b: { run: base.get(c).n, skipped: base.get(c).sk }, h: { run: c.n ?? 0, skipped: c.sk ?? 0 } };
+    const progress = checks.some((c) => wall.has(c.name) && c.result === "pass") || sus.some(({ c }) => !out2.weak.includes(c.name) && base.get(c).red.length > 0 && (c.n ?? 0) >= base.get(c).n);
+    if (progress) {
+      for (const { c } of un) {
+        if (!rel.has(c.name) && c.result === "fail" && c.ids?.length && c.ids.every((i) => base.get(c).red.includes(i))) {
+          out2.names.push(c.name);
+          out2.ids.push(...c.ids);
+        }
+      }
+    }
+  } catch {} finally {
+    try {
+      git2(["worktree", "remove", "--force", dir]);
+    } catch {}
+    rmSync8(dir, { recursive: true, force: true });
+    try {
+      git2(["worktree", "prune"]);
+    } catch {}
+  }
+  return out2;
+}
+function isLokiModeRepo(repoDir) {
+  return existsSync20(join38(repoDir, "scripts", "select-tests.sh"));
+}
+var ESLINT_CONFIGS = [".eslintrc", ".eslintrc.json", ".eslintrc.js", ".eslintrc.cjs", "eslint.config.js", "eslint.config.mjs", "eslint.config.cjs"];
+async function runLintChecks(ctx, changed, signal, checks, opts = {}) {
+  const { api, ...runOpts } = opts;
+  opts = runOpts;
+  const py = changed.filter((f) => f.endsWith(".py"));
+  if (py.length) {
+    const [ruffCmd, interpreter] = resolveTool(ctx.repoDir, "ruff", "ruff");
+    await runCheck(ctx, "lint:ruff", ruffCmd, ["check", ...py], signal, checks, { ...opts, interpreter, kind: "static" });
+  }
+  const sh = changed.filter((f) => f.endsWith(".sh"));
+  if (sh.length) {
+    await runCheck(ctx, "lint:bash-n", "bash", ["-c", 'for f in "$@"; do bash -n "$f" || exit 1; done', "_", ...sh], signal, checks, { ...opts, kind: "static" });
+    await runCheck(ctx, "lint:shellcheck", "shellcheck", sh, signal, checks, { ...opts, kind: "static" });
+  }
+  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 (existsSync20(join38(g.cwd, "tsconfig.json")))
+      await runCheck(ctx, `lint:tsc${sfx}`, "npx", ["tsc", "--noEmit", "-p", "."], signal, checks, { ...co, kind: "static" });
+    if (ESLINT_CONFIGS.some((f) => existsSync20(join38(g.cwd, f))))
+      await runCheck(ctx, `lint:eslint${sfx}`, "npx", ["eslint", ...g.rel], signal, checks, { ...co, kind: "static" });
+  }
+}
+var verifyStage = {
+  name: "verify",
+  targetS: STAGE_BUDGETS.verify.targetS,
+  limitS: STAGE_BUDGETS.verify.limitS,
+  async run(ctx, signal) {
+    let changed;
+    try {
+      changed = changedFiles(ctx.repoDir, ctx.baseSha);
+    } catch (err) {
+      return { status: "failed", data: {}, reason: `git diff against base failed: ${err.message}` };
+    }
+    if (changed.length === 0) {
+      const implementExit = ctx.outputs().implement?.exit;
+      if (implementExit === "already_done") {
+        return { status: "completed", data: { already_satisfied: true, checks: [], flaky: [], failures_grouped: [], changed_files: [] } };
+      }
+      return { status: "failed", data: { changed_files: [] }, reason: "empty diff without an already_done marker" };
+    }
+    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) => isAbsolute4(f.path) ? relative4(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]);
+    const scopedOut = scopedOutOf(map);
+    if (scopedOut.length)
+      ctx.emit("test.scoped_out", "verify", { tests: scopedOut });
+    for (const t of tests) {
+      if (signal.aborted)
+        break;
+      const tc = commandFor(t, ctx.repoDir, api);
+      await runCheck(ctx, `${t.runner}:${t.path}`, tc.cmd, tc.args, signal, checks, { ...tc.interpreter ? { interpreter: tc.interpreter } : {}, protect: [...wallTests, ...relevant].includes(t), ...tc.pkgRoot !== "." ? { cwd: tc.cwd } : {} });
+    }
+    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);
+    if (!signal.aborted) {
+      await runLintChecks(ctx, changed, signal, checks, { api, wall: wallPaths });
+      if (isLokiModeRepo(ctx.repoDir)) {
+        await runCheck(ctx, "select-tests", "bash", ["scripts/select-tests.sh", "--files", "-", "--run"], signal, checks, {
+          kind: "static",
+          stdin: changed.join(`
+`) + `
+`
+        });
+      }
+    }
+    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));
+    const flaky = checks.filter((c) => c.result === "flaky").map((c) => c.name);
+    const failuresGrouped = checks.filter((c) => c.result === "fail" && !preRed.names.includes(c.name)).map((c) => ({ signature: c.first_error ? `${c.name} ${c.first_error}` : c.name, count: 1, sample: c.cmd }));
+    const inBase = (f) => {
+      try {
+        safeGit(ctx.repoDir, ["cat-file", "-e", `${ctx.baseSha}:${f}`], { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const testCounts = {};
+    const modifiedRel = relevant.filter((t) => changed.includes(t.path) && inBase(t.path)).flatMap((t) => {
+      const k = preRed.cnt[`${t.runner}:${t.path}`];
+      if (k)
+        testCounts[t.path] = k;
+      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) } };
+  }
+};
+
+// ../../loki-ts/src/engine10/stages/wall.ts
+var BASE_RUN_TIMEOUT_MS = 60000;
+function pytestCollectionIsRed(output, repoDir) {
+  if (/ModuleNotFoundError/.test(output))
+    return false;
+  const real2 = (p) => {
+    try {
+      return realpathSync17(isAbsolute5(p) ? p : join39(repoDir, p));
+    } catch {
+      return null;
+    }
+  };
+  const repoReal = real2(repoDir);
+  const under = (p) => {
+    const r = real2(p);
+    return !!repoReal && !!r && (r === repoReal || r.startsWith(`${repoReal}/`));
+  };
+  const imp = /ImportError: cannot import name .* from ['"][\w.]+['"] \(([^)]+)\)/.exec(output);
+  if (imp)
+    return under(imp[1]);
+  const hdr = [...output.matchAll(/^=+ short test summary info =+$/gm)].pop();
+  if (!hdr)
+    return false;
+  const cls = [...output.slice(hdr.index).matchAll(/^ERROR \S+ - (\w+Error): /gm)].pop()?.[1];
+  if (cls !== "AttributeError" && cls !== "NameError")
+    return false;
+  const start = output.search(/^_+ ERROR collecting /m);
+  if (start < 0 || start > hdr.index)
+    return false;
+  const block = output.slice(start, hdr.index).split(/^-+ Captured .*$/m)[0];
+  const eLines = [...block.matchAll(new RegExp(`^E {3}${cls}: (.*)$`, "gm"))];
+  const eLine = eLines[eLines.length - 1];
+  if (!eLine)
+    return false;
+  if (cls === "AttributeError") {
+    const m = /^module ['"]([\w.]+)['"] has no attribute/.exec(eLine[1]);
+    return !!m && moduleUnderRepo(repoDir, m[1]);
+  }
+  const frames = [...block.slice(0, eLine.index).matchAll(/^(.+?):\d+: in \S+\n\s*(.*)$/gm)];
+  const last = frames[frames.length - 1];
+  return !!last && under(last[1]) && !/^\s*(import\s|from\s\S+\s+import\b)/.test(last[2] ?? "");
+}
+function moduleUnderRepo(repoDir, name) {
+  const rel = name.replace(/\./g, "/");
+  return existsSync21(join39(repoDir, `${rel}.py`)) || existsSync21(join39(repoDir, rel, "__init__.py"));
+}
+function pytestExit1IsRed(output) {
+  if (/^!+ _pytest\.outcomes\.Exit\b/m.test(output))
+    return false;
+  if (/^=*\s*(\d+ \w+(, )?)*\d+ failed\b.* in [\d.]+s/.test(output.trimEnd().split(`
+`).pop() ?? ""))
+    return true;
+  const hdr = [...output.matchAll(/^=+ short test summary info =+$/gm)].pop();
+  return !!hdr && /^FAILED \S+/m.test(output.slice(hdr.index));
+}
+function parsedFailCount(runner, output) {
+  const m = runner === "bun" ? /^\s*(\d+)\s+fail\s*$/m.exec(output) : runner === "jest" ? /Tests:\s*(\d+)\s+failed/i.exec(output) : runner === "vitest" ? /Tests\s+(\d+)\s+failed/i.exec(output) : null;
+  return m ? Number(m[1]) : 0;
+}
+function nodeIsRed(f, raw2) {
+  const o = raw2.replace(/^# (?!(?:tests|suites|pass|fail|cancelled|skipped|todo|duration_ms|Subtest)\b)/gm, "");
+  const mod = /^Error(?: \[\w+\])?: Cannot find (?:module|package) '([^']+)'(?:(?!\u2716)[\s\S])*?\nNode\.js v/m.exec(o), top = /^(\S+):\d+\n.*\n.*\n\n?(?:ReferenceError|SyntaxError)\b/m.exec(o);
+  const named = [...o.matchAll(/^(?:\u2716|\s*not ok \d+ -) (?!failing tests:)(.+?)(?: \(|$)/gm)].some((m) => !f.path.endsWith(m[1]) && !m[1].endsWith(f.path)), blk = o.split("failing tests:")[1] ?? "", esm = /^SyntaxError: The requested module '([^']+)' does not provide an export named/m.exec(o), errs = [...blk.matchAll(/^ {2}(\w+Error): .*\n\s+at (?:.*\()?([^\s()]+?):\d+:\d+/gm), ...o.matchAll(/^ +name: '(\w+Error)'\n(?:.*\n)*? +stack: \|-\n\s+(?:.*\()?([^\s()]+?):\d+:\d+/gm)];
+  return /^(?:#|\u2139) fail [1-9]/m.test(raw2) && (/^ {2}AssertionError\b/m.test(blk) || /^ +name: 'AssertionError'/m.test(o) || (mod && !named ? /^[./]/.test(mod[1]) : esm ? /^[./]/.test(esm[1]) : top ? !top[1].endsWith(f.path) : !errs.length || errs.some((e) => !/^(?:Reference|Syntax)Error$/.test(e[1]) || !(e[2].startsWith("node:") || e[2].endsWith(f.path)))));
+}
+function classify(f, status, output, repoDir, interpreter) {
+  if (interpreter === "system")
+    return "not_run";
+  if (status === null || status === 126 || status === 127)
+    return "not_run";
+  if (status === 0)
+    return classifyCheck({ kind: "test", ok: true, out: output, path: f.path, ...f.runner === "go" ? { runner: "go" } : {} }).result === "pass" ? "pass" : "not_run";
+  if (f.runner === "pytest")
+    return status === 1 ? pytestExit1IsRed(output) ? "fail" : "not_run" : status === 2 ? pytestCollectionIsRed(output, repoDir) ? "fail" : "not_run" : "not_run";
+  if (f.runner === "jest" || f.runner === "vitest" || f.runner === "bun")
+    return parsedFailCount(f.runner, output) > 0 ? "fail" : "not_run";
+  return f.runner === "node" && nodeIsRed(f, output) ? "fail" : "not_run";
+}
+
+class RealBaseTestRunner {
+  api;
+  timeoutMs;
+  constructor(api, timeoutMs = BASE_RUN_TIMEOUT_MS) {
+    this.api = api;
+    this.timeoutMs = timeoutMs;
+  }
+  run(repoDir, files) {
+    let pass = 0, fail = 0, not_run = 0;
+    const api = this.api === undefined ? loadProjectApi(repoDir) : this.api;
+    for (const f of files) {
+      const { cmd, args, interpreter, cwd } = commandFor(f, repoDir, api);
+      const r = spawnSync3(cmd, f.runner === "pytest" ? [...args, "-rfE"] : args, { cwd, encoding: "utf8", timeout: Math.max(1000, this.timeoutMs), env: process.env });
+      const status = r.error ? null : r.status;
+      const result = classify(f, status, `${r.stdout ?? ""}
+${r.stderr ?? ""}`, repoDir, interpreter);
+      if (result === "pass")
+        pass++;
+      else if (result === "fail")
+        fail++;
+      else
+        not_run++;
+    }
+    return { pass, fail, not_run };
+  }
+}
+
+// ../../loki-ts/src/e10ext/discard.ts
+import { chmodSync as chmodSync4, closeSync as closeSync6, lstatSync as lstatSync6, mkdirSync as mkdirSync10, openSync as openSync6, readFileSync as readFileSync26, realpathSync as realpathSync18, rmdirSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname12, join as join40, relative as relative6, sep as sep11 } from "path";
+function safeRestore(repoDir, f, want, mode) {
+  const root = realpathSync18(repoDir), fp = join40(root, f), rel = relative6(root, dirname12(fp));
+  if (rel.startsWith(".."))
+    throw new Error("outside repo");
+  let cur = root;
+  for (const part of rel === "" ? [] : rel.split(sep11)) {
+    cur = join40(cur, part);
+    let st2;
+    try {
+      st2 = lstatSync6(cur);
+    } catch {
+      mkdirSync10(cur);
+      continue;
+    }
+    if (!st2.isDirectory())
+      throw new Error("parent is not a real directory");
+  }
+  let st;
+  try {
+    st = lstatSync6(fp);
+  } catch {
+    st = null;
+  }
+  if (st?.isFile() && readFileSync26(fp).equals(want)) {
+    chmodSync4(fp, mode);
+    return;
+  }
+  if (st) {
+    if (st.isDirectory())
+      rmdirSync(fp);
+    else
+      unlinkSync3(fp);
+  }
+  const fd = openSync6(fp, "wx", mode);
+  try {
+    writeFileSync13(fd, want);
+  } finally {
+    closeSync6(fd);
+  }
+  chmodSync4(fp, mode);
+}
+function alreadySatisfied(o) {
+  const b = o.wall?.base_run ?? {};
+  return o.intake?.already_satisfied === true || o.implement?.exit === "already_done" || typeof b.pass === "number" && b.pass > 0 && b.fail === 0 && (b.not_run ?? 0) === 0;
+}
+function catBlob(repoDir, sha2) {
+  const r = safeGitSpawn(repoDir, ["cat-file", "blob", sha2], { maxBuffer: 1 << 28 });
+  if (r.error || r.status !== 0)
+    throw r.error ?? new Error(`git cat-file blob ${sha2} failed`);
+  return r.stdout;
+}
+async function discardIfSatisfied(git2, base, o, staged, keep, repoDir) {
+  if (!alreadySatisfied(o))
+    return null;
+  const pre = Object.assign(Object.create(null), o.intake?.preexisting_dirty ?? {}), own = new Set([...Array.isArray(o.intake?.preexisting_untracked) ? o.intake.preexisting_untracked : [], ...Object.keys(o.intake?.preexisting_untracked_blobs ?? {})]);
+  const gone = staged.filter(({ f }) => !keep.has(f) && !own.has(f) && !Object.hasOwn(pre, f) && !f.startsWith(".loki/")), lit = ["--literal-pathspecs"];
+  const del = gone.filter(({ st }) => st === "A").map(({ f }) => f), back = gone.filter(({ st }) => st !== "A").map(({ f }) => f);
+  if (del.length > 0 && (await git2([...lit, "rm", "-q", "-f", "--", ...del])).code !== 0 || back.length > 0 && (await git2([...lit, "restore", `--source=${base}`, "--staged", "--worktree", "--", ...back])).code !== 0 || (await git2(["reset", "-q", base])).code !== 0)
+    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 = join40(repoDir, f);
+    try {
+      if (v.startsWith("!")) {
+        const st = lstatSync6(fp);
+        if (`!${st.size}:${st.mtimeMs}:${st.ctimeMs}` !== v)
+          throw new Error("changed, not snapshotted");
+        continue;
+      }
+      const [sha2, mode] = v.split(" "), want = catBlob(repoDir, sha2);
+      safeRestore(repoDir, f, want, parseInt(mode ?? "644", 8));
+    } catch {
+      notProven.push(f);
+    }
+  }
+  for (const f of Object.keys(pre))
+    if (staged.some((s) => s.f === f) && !keep.has(f)) {
+      try {
+        let m = 420;
+        try {
+          const l = lstatSync6(join40(repoDir, f));
+          if (l.isFile())
+            m = l.mode & 511;
+        } catch {}
+        safeRestore(repoDir, f, catBlob(repoDir, pre[f]), m);
+      } catch {
+        notProven.push(f);
+      }
+    }
+  return { status: "completed", data: { committed: false, discarded: gone.length, ...notProven.length > 0 ? { not_proven: notProven.map((f) => `pre-existing file not restored: ${f}`) } : {} } };
+}
+
+// ../../loki-ts/src/e10ext/commit_filter.ts
+import { dirname as dirname13 } from "path";
+
+// ../../loki-ts/src/e10ext/preexisting_dirty.ts
+var blob2 = (repoDir, path, env = process.env) => safeGit(repoDir, ["hash-object", "-w", "--no-filters", "--", path], { env }).trim();
+function untouchedSinceIntake(repoDir, recorded, env = process.env) {
+  if (!recorded || typeof recorded !== "object")
+    return [];
+  return Object.entries(recorded).filter(([p, h]) => {
+    try {
+      return blob2(repoDir, p, env) === h;
+    } catch {
+      return false;
+    }
+  }).map(([p]) => p);
+}
+
+// ../../loki-ts/src/e10ext/commit_filter.ts
+var parseStaged = (out2) => out2.split("\x00").reduce((a, t, i, all) => i % 2 === 0 && t ? [...a, { st: t, f: all[i + 1] }] : a, []);
+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) && dirname13(m) === dirname13(f)) && /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|poetry\.lock|Cargo\.lock|go\.sum)$/.test(f));
 }
 
+// ../../loki-ts/src/e10ext/scope.ts
+import { basename as basename15, dirname as dirname14 } from "path";
+
 // ../../loki-ts/src/features/speed/unit_mode.ts
-import { closeSync as closeSync6, constants, fstatSync as fstatSync4, lstatSync as lstatSync6, openSync as openSync6, readSync as readSync4, realpathSync as realpathSync16 } from "fs";
+import { closeSync as closeSync7, constants, fstatSync as fstatSync4, lstatSync as lstatSync7, openSync as openSync7, readSync as readSync5, realpathSync as realpathSync19 } from "fs";
 var MAX_SPEC_BYTES = 1024 * 1024;
 var MAX_TOKEN_BUDGET = 1e9;
 var norm2 = (p) => p.replace(/^\.\//, "");
 var CTRL = /[\x00-\x1f\x7f]/;
 var strs = (v) => Array.isArray(v) && v.every((x) => typeof x === "string" && !CTRL.test(x)) ? v.map(norm2) : null;
 function readBounded(path) {
-  const l = lstatSync6(path);
+  const l = lstatSync7(path);
   if (l.isSymbolicLink() || !l.isFile() || l.size > MAX_SPEC_BYTES)
     return null;
-  const fd = openSync6(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  const fd = openSync7(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
   try {
     const st = fstatSync4(fd);
     if (!st.isFile() || st.size > MAX_SPEC_BYTES)
@@ -18250,7 +19668,7 @@ function readBounded(path) {
     const buf = Buffer.alloc(st.size + 1);
     let n2 = 0;
     for (;; ) {
-      const r = readSync4(fd, buf, n2, buf.length - n2, null);
+      const r = readSync5(fd, buf, n2, buf.length - n2, null);
       if (r <= 0)
         break;
       n2 += r;
@@ -18259,7 +19677,7 @@ function readBounded(path) {
     }
     return buf.subarray(0, n2).toString("utf8");
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 function parseText(txt) {
@@ -18300,8 +19718,8 @@ function unitFlags(staged, env = process.env, pre = {}) {
 // ../../loki-ts/src/e10ext/scope.ts
 var SCOPE_UNDETERMINED = "scope not determined; all edits committed";
 var outsideNote = (f) => `outside stated scope: ${f}`;
-var esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var mentions = (text2, name) => new RegExp(`(?<![\\w./-])${esc(name)}(?![\\w-]|\\.\\w)`).test(text2);
+var esc2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var mentions = (text2, name) => new RegExp(`(?<![\\w./-])${esc2(name)}(?![\\w-]|\\.\\w)`).test(text2);
 var STOP = new Set(["the", "and", "for", "with", "that", "this", "all", "any", "src", "from", "into", "each", "across", "apply", "add", "use", "make"]);
 var stem = (w) => w.length > 3 && w.endsWith("s") ? w.slice(0, -1) : w;
 var surfaceTokens = (text2) => new Set((text2.toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g) ?? []).filter((w) => !STOP.has(w)).map(stem));
@@ -18319,8 +19737,8 @@ function outsideScope(o, staged) {
   const text2 = `${plan}
 ${typeof o.intake?.task === "string" ? o.intake.task : ""}
 ${contractText(o)}`, pre = o.intake?.preexisting_dirty ?? {};
-  const toks = surfaceTokens(text2), plannedDirs = new Set(rel.map((r) => dirname9(r)).filter((d) => d !== "."));
-  return staged.filter(({ st, f }) => st !== "A" && !isTestFile(f) && !Object.hasOwn(pre, f) && !rel.includes(f) && !mentions(text2, f) && !mentions(text2, basename10(f)) && !plannedDirs.has(dirname9(f)) && !dirSegs(f).some((d) => toks.has(d))).map(({ f }) => f);
+  const toks = surfaceTokens(text2), plannedDirs = new Set(rel.map((r) => dirname14(r)).filter((d) => d !== "."));
+  return staged.filter(({ st, f }) => st !== "A" && !isTestFile(f) && !Object.hasOwn(pre, f) && !rel.includes(f) && !mentions(text2, f) && !mentions(text2, basename15(f)) && !plannedDirs.has(dirname14(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 ?? {});
@@ -18331,80 +19749,96 @@ function flagOutsideScope(o, staged) {
 // ../../loki-ts/src/util/receipt_signer.ts
 var RECEIPT_SIGNER_BASENAME = "receipt-ed25519.pem";
 
-// ../../loki-ts/src/util/shell.ts
-var MAX_STDOUT_BYTES = 16 * 1024 * 1024;
-async function readStreamCapped(stream, maxBytes = MAX_STDOUT_BYTES) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let out2 = "";
-  let total = 0;
+// ../../loki-ts/src/util/pr_lessons.ts
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync27 } from "fs";
+import { dirname as dirname16, join as join41 } from "path";
+
+// ../../loki-ts/src/util/atomic.ts
+import {
+  closeSync as closeSync8,
+  fstatSync as fstatSync5,
+  fsyncSync as fsyncSync2,
+  lstatSync as lstatSync8,
+  mkdirSync as mkdirSync11,
+  openSync as openSync8,
+  readSync as readSync6,
+  renameSync as renameSync5,
+  rmSync as rmSync10,
+  statSync as statSync12,
+  unlinkSync as unlinkSync4,
+  writeSync as writeSync3
+} from "fs";
+import { dirname as dirname15 } from "path";
+var _tmpCounter = 0;
+function durableWriteThenRename(target, body) {
+  mkdirSync11(dirname15(target), { recursive: true });
+  const tmp = `${target}.tmp.${process.pid}.${++_tmpCounter}`;
+  const fd = openSync8(tmp, "w");
   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();
+    writeSync3(fd, body);
+    fsyncSync2(fd);
   } finally {
-    try {
-      await reader.cancel();
-    } catch {}
-    reader.releaseLock();
+    closeSync8(fd);
   }
-  return out2;
+  renameSync5(tmp, target);
+  fsyncParentDir(target);
 }
-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(() => {
+function fsyncParentDir(target) {
+  let dfd = null;
+  try {
+    dfd = openSync8(dirname15(target), "r");
+    fsyncSync2(dfd);
+  } catch {} finally {
+    if (dfd !== null) {
       try {
-        proc.kill("SIGTERM");
+        closeSync8(dfd);
       } catch {}
-      killTimer = setTimeout(() => {
-        try {
-          proc.kill("SIGKILL");
-        } catch {}
-      }, 2000);
-    }, opts.timeoutMs);
+    }
   }
+}
+function atomicWriteJson(target, data) {
+  durableWriteThenRename(target, `${JSON.stringify(data, null, 2)}
+`);
+}
+var _appendChains = new Map;
+
+// ../../loki-ts/src/util/pr_lessons.ts
+var lessonsPath = (repoDir) => join41(repoDir, ".loki", "memory", "semantic", "pr-lessons.json");
+function loadLessons(repoDir) {
+  const p = lessonsPath(repoDir);
+  if (!existsSync22(p))
+    return [];
   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);
+    const j = JSON.parse(readFileSync27(p, "utf-8"));
+    return Array.isArray(j.lessons) ? j.lessons : [];
+  } catch {
+    return [];
   }
 }
+function save(repoDir, lessons) {
+  const p = lessonsPath(repoDir);
+  mkdirSync12(dirname16(p), { recursive: true });
+  atomicWriteJson(p, { version: 1, 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);
+}
 
 // ../../loki-ts/src/features/visual_evidence.ts
 import { spawn as spawn7 } from "child_process";
-import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync17, lstatSync as lstatSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync9, readFileSync as readFileSync21, writeFileSync as writeFileSync10 } from "fs";
+import { createHash as createHash8, randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync23, lstatSync as lstatSync9, mkdirSync as mkdirSync13, readdirSync as readdirSync12, readFileSync as readFileSync28, writeFileSync as writeFileSync14 } from "fs";
 import { createServer } from "net";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join31, normalize as normalize2, relative as relative3, sep as sep12 } from "path";
+import { dirname as dirname17, isAbsolute as isAbsolute6, join as join42, normalize as normalize2, relative as relative7, sep as sep12 } from "path";
 var visualEvidenceEnabled = (env = process.env) => env["LOKI_VISUAL_EVIDENCE"] !== "0";
 var PAGE_RE = /^(?:.*\/)?(?:app|pages|src|public)\/.*\.(?:html|jsx|tsx|vue|svelte)$/;
 var isPageFile = (p) => PAGE_RE.test(p);
@@ -18414,12 +19848,12 @@ function routeFor(file) {
   return `/${r}`.replace(/\/+/g, "/");
 }
 var screenName = (route) => (route === "/" ? "index" : route.slice(1).replace(/[^A-Za-z0-9._-]+/g, "_")) || "index";
-var sha256File = (p) => createHash6("sha256").update(readFileSync21(p)).digest("hex");
+var sha256File = (p) => createHash8("sha256").update(readFileSync28(p)).digest("hex");
 function hashScreens(runDir, rels) {
   const out2 = [];
   for (const rel of rels) {
     try {
-      out2.push({ path: rel, sha256: sha256File(join31(runDir, rel)) });
+      out2.push({ path: rel, sha256: sha256File(join42(runDir, rel)) });
     } catch {}
   }
   return out2;
@@ -18430,16 +19864,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 (isAbsolute2(s.path) || normalize2(s.path).startsWith(".."))
+    if (isAbsolute6(s.path) || normalize2(s.path).startsWith(".."))
       return `evidence screenshot path escapes the evidence dir: ${s.path}`;
-    const file = join31(runDir, s.path);
+    const file = join42(runDir, s.path);
     let cur = runDir;
     for (const seg of normalize2(s.path).split(sep12)) {
-      cur = join31(cur, seg);
+      cur = join42(cur, seg);
       if (isSymlink(cur))
         return `evidence screenshot path is a symlink: ${s.path}`;
     }
-    if (!existsSync17(file))
+    if (!existsSync23(file))
       return `evidence screenshot is missing: ${s.path}`;
     if (!isRegularFile(file))
       return `evidence screenshot is not a regular file: ${s.path}`;
@@ -18481,16 +19915,16 @@ async function waitUp(url, ms, signal) {
   return false;
 }
 var playwrightBin = (repoDir) => {
-  const bin = join31(repoDir, "node_modules", ".bin", "playwright");
-  return existsSync17(bin) ? bin : null;
+  const bin = join42(repoDir, "node_modules", ".bin", "playwright");
+  return existsSync23(bin) ? bin : null;
 };
 function openapiPaths(repoDir) {
   for (const f of ["openapi.json", "openapi.yaml", "openapi.yml", "swagger.json"]) {
-    const p = join31(repoDir, f);
-    if (!existsSync17(p))
+    const p = join42(repoDir, f);
+    if (!existsSync23(p))
       continue;
     try {
-      const txt = readFileSync21(p, "utf8");
+      const txt = readFileSync28(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 {
@@ -18500,8 +19934,8 @@ function openapiPaths(repoDir) {
   return [];
 }
 var playwrightTestPkg = (repoDir) => {
-  const d = join31(repoDir, "node_modules", "@playwright", "test");
-  return existsSync17(join31(d, "package.json")) ? d : null;
+  const d = join42(repoDir, "node_modules", "@playwright", "test");
+  return existsSync23(join42(d, "package.json")) ? d : null;
 };
 var e2eSpecSource = (pkgDir, base, routes) => `const { test } = require(${JSON.stringify(pkgDir)});
 test("loki e2e walkthrough", async ({ page }) => {
@@ -18513,24 +19947,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 = join31(runDir, relDir, "e2e");
-    mkdirSync7(dir, { recursive: true });
-    writeFileSync10(join31(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
-    writeFileSync10(join31(dir, "playwright.config.cjs"), `module.exports = { testDir: ".", testMatch: "walk.spec.cjs", outputDir: "./out", reporter: "null", use: { video: "on", trace: "on" } };
+    const dir = join42(runDir, relDir, "e2e");
+    mkdirSync13(dir, { recursive: true });
+    writeFileSync14(join42(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
+    writeFileSync14(join42(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", join31(dir, "playwright.config.cjs")], repoDir, ms, signal))
+    if (!await shoot(pw, ["test", "--config", join42(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 readdirSync9(d, { withFileTypes: true })) {
-        const full = join31(d, e.name);
+      for (const e of readdirSync12(d, { withFileTypes: true })) {
+        const full = join42(d, e.name);
         if (e.isDirectory())
           walk(full);
         else if (e.isFile() && /\.(webm|zip)$/.test(e.name))
-          rels.push(join31(relDir, "e2e", relative3(dir, full)));
+          rels.push(join42(relDir, "e2e", relative7(dir, full)));
       }
     };
-    walk(join31(dir, "out"));
+    walk(join42(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)}` };
@@ -18568,14 +20002,14 @@ function shoot(pw, args, cwd, ms, signal) {
 }
 var isSymlink = (p) => {
   try {
-    return lstatSync7(p).isSymbolicLink();
+    return lstatSync9(p).isSymbolicLink();
   } catch {
     return false;
   }
 };
 var isRegularFile = (p) => {
   try {
-    return lstatSync7(p).isFile();
+    return lstatSync9(p).isFile();
   } catch {
     return false;
   }
@@ -18624,13 +20058,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 ? join31(repoDir, boot.boot.cwd) : repoDir;
-    const pkgPath = join31(appDir, "package.json");
+    const appDir = boot ? join42(repoDir, boot.boot.cwd) : repoDir;
+    const pkgPath = join42(appDir, "package.json");
     let script = null;
     if (!boot) {
-      if (!existsSync17(pkgPath))
+      if (!existsSync23(pkgPath))
         return skip("no package.json");
-      script = pickScript(JSON.parse(readFileSync21(pkgPath, "utf8")));
+      script = pickScript(JSON.parse(readFileSync28(pkgPath, "utf8")));
       if (!script)
         return skip("no dev, preview or start script");
     }
@@ -18657,20 +20091,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 = join31(runDir, "evidence");
+    const evRoot = join42(runDir, "evidence");
     if (isSymlink(evRoot))
       return skip("evidence dir is a symlink");
-    mkdirSync7(evRoot, { recursive: true });
+    mkdirSync13(evRoot, { recursive: true });
     if (pages.length > 0) {
-      const rel0 = join31("evidence", randomBytes2(6).toString("hex"));
-      mkdirSync7(join31(runDir, rel0));
+      const rel0 = join42("evidence", randomBytes2(6).toString("hex"));
+      mkdirSync13(join42(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 = join31(rel0, `${screenName(route)}.png`);
-        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join31(runDir, rel)], appDir, left(), signal);
-        if (ok && !aborted() && !isSymlink(join31(runDir, rel)) && existsSync17(join31(runDir, rel)))
+        const rel = join42(rel0, `${screenName(route)}.png`);
+        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join42(runDir, rel)], appDir, left(), signal);
+        if (ok && !aborted() && !isSymlink(join42(runDir, rel)) && existsSync23(join42(runDir, rel)))
           rels.push(rel);
       }
       if (aborted())
@@ -18695,9 +20129,9 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
     }
     if (aborted())
       return skip("aborted");
-    const hdir = join31(evRoot, randomBytes2(6).toString("hex"));
-    mkdirSync7(hdir);
-    writeFileSync10(join31(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
+    const hdir = join42(evRoot, randomBytes2(6).toString("hex"));
+    mkdirSync13(hdir);
+    writeFileSync14(join42(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
 `);
     return { screens: [], http: true, skipped: null };
   } catch (e) {
@@ -18720,12 +20154,13 @@ 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(dirname10(receiptPath), receipt["evidence_screens"]);
+  return receipt["evidence_screens"] === undefined ? null : checkScreens(dirname17(receiptPath), receipt["evidence_screens"]);
 }
 
 // ../../loki-ts/src/engine10/stages/xreview.ts
-import { existsSync as existsSync18, readFileSync as readFileSync22 } from "fs";
-import { join as join32 } from "path";
+init_shell();
+import { existsSync as existsSync24, readFileSync as readFileSync29 } from "fs";
+import { join as join43 } from "path";
 var RANK2 = { FAILED: 0, SPEC_CONFLICT: 0, PARTIAL: 1, ALREADY_SATISFIED: 2, VERIFIED: 2 };
 var TIMEOUT_MS = 300000;
 var MAX_DIFF = 60000;
@@ -18743,11 +20178,11 @@ function reviewProvider(repoDir, env = process.env) {
   if (e)
     return e;
   for (const f of ["loki.yaml", "loki.yml"]) {
-    const p = join32(repoDir, f);
-    if (!existsSync18(p))
+    const p = join43(repoDir, f);
+    if (!existsSync24(p))
       continue;
     try {
-      const m = /^review:[ \t]*["']?([A-Za-z]+)["']?[ \t]*(?:#.*)?$/m.exec(readFileSync22(p, "utf8"));
+      const m = /^review:[ \t]*["']?([A-Za-z]+)["']?[ \t]*(?:#.*)?$/m.exec(readFileSync29(p, "utf8"));
       const v = asProvider(m?.[1]);
       if (v)
         return v;
@@ -18775,7 +20210,7 @@ async function crossReview(ctx, verdict, head) {
     return null;
   if (verdict !== "VERIFIED" && verdict !== "ALREADY_SATISFIED")
     return null;
-  const d = await run(safeGitArgv(["diff", "--no-ext-diff", "--no-color", ctx.baseSha, head, "--", ".", ":(exclude).loki"], false, ctx.repoDir), { cwd: ctx.repoDir, env: safeGitEnv(), timeoutMs: 20000 }).catch(() => null);
+  const d = await safeGitRun(ctx.repoDir, ["diff", "--no-color", ctx.baseSha, head, "--", ".", ":(exclude).loki"], { timeoutMs: 20000 }).catch(() => null);
   if (!d || d.exitCode !== 0)
     return { provider: p, level: "not_run", notes: [`cross-review not run: diff unavailable for ${p}`] };
   const prompt = [
@@ -18797,17 +20232,6 @@ async function crossReview(ctx, verdict, head) {
   }
 }
 
-// ../../loki-ts/src/runner/router/flag.ts
-function routerMode(env = process.env) {
-  const v = (env.LOKI_ROUTER ?? "").trim().toLowerCase();
-  if (v === "0" || v === "false" || v === "off")
-    return "opt-out";
-  if (v === "1" || v === "true" || v === "on")
-    return "on";
-  return "off";
-}
-var routerEnabled = (env = process.env) => routerMode(env) === "on";
-
 // ../../loki-ts/src/runner/router/route_block.ts
 var ALIAS = { haiku: "haiku-5.5", sonnet: "sonnet-5.5", opus: "opus-5.5" };
 var modelLabel = (m) => ALIAS[m] ?? m;
@@ -18824,13 +20248,14 @@ var nN = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
 var rec = (v) => v === null ? "not recorded" : String(v);
 var s0 = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
 function toEsc(raw2) {
-  const esc2 = Array.isArray(raw2) ? raw2 : [];
-  return esc2.map((e) => ({ trigger: s0(e["trigger"]) ?? "unknown", from: modelLabel(s0(e["from"]) ?? "?"), to: modelLabel(s0(e["to"]) ?? "?"), evidence: s0(e["evidence"]) ?? "none recorded" }));
+  const esc3 = Array.isArray(raw2) ? raw2 : [];
+  return esc3.map((e) => ({ trigger: s0(e["trigger"]) ?? "unknown", from: modelLabel(s0(e["from"]) ?? "?"), to: modelLabel(s0(e["to"]) ?? "?"), evidence: s0(e["evidence"]) ?? "none recorded" }));
 }
 var assignedBy = (src, explicit) => s0(explicit) ?? (src === null || src === "opus" ? "opus" : src);
-function buildRouteBlock(env, provider, route, telemetry) {
+function buildRouteBlock(env, provider, route, telemetry, runModel) {
   if (!routerEnabled(env))
     return null;
+  const applied = route?.["applied"] !== false;
   const executor = s0(route?.["executor"]);
   const unavailable = s0(route?.["advisor_unavailable_reason"]) ?? advisorUnavailableReason(env, provider);
   const total = nN(telemetry?.requests_total);
@@ -18840,11 +20265,11 @@ function buildRouteBlock(env, provider, route, telemetry) {
   const source = s0(route?.["source"]);
   const reason = s0(route?.["reason"]) ?? (executor ? "no reason recorded" : "no route recorded by implement");
   const rawUnits = Array.isArray(route?.["units"]) ? route["units"] : [];
-  const units = rawUnits.length > 0 ? rawUnits.map((u, i) => ({ id: s0(u["id"]) ?? String(i + 1), executor: modelLabel(s0(u["executor"]) ?? "unknown"), assigned_by: assignedBy(s0(u["source"]) ?? source, u["assigned_by"]), reason: s0(u["reason"]) ?? "no reason recorded", escalations: toEsc(u["escalations"]) })) : executor ? [{ id: "run", executor: modelLabel(executor), assigned_by: assignedBy(source, route?.["assigned_by"]), reason, escalations }] : [];
+  const units = rawUnits.length > 0 ? rawUnits.map((u, i) => ({ id: s0(u["id"]) ?? String(i + 1), executor: modelLabel(s0(u["executor"]) ?? "unknown"), applied, assigned_by: assignedBy(s0(u["source"]) ?? source, u["assigned_by"]), reason: s0(u["reason"]) ?? "no reason recorded", escalations: toEsc(u["escalations"]) })) : executor && route?.["routed"] !== false ? [{ id: "run", executor: modelLabel(executor), applied, assigned_by: assignedBy(source, route?.["assigned_by"]), reason, escalations }] : [];
   return {
-    routed: executor !== null || units.length > 0,
+    routed: route?.["routed"] === false ? false : executor !== null || units.length > 0,
     units,
-    executor: executor ? modelLabel(executor) : units[0]?.executor ?? null,
+    executor: !applied ? `${runModel ? modelLabel(runModel) : "run model"} (per-unit assignment not applied)` : executor ? modelLabel(executor) : units[0]?.executor ?? null,
     advisor: unavailable ? null : modelLabel(s0(route?.["advisor"]) ?? "opus"),
     advisor_unavailable_reason: unavailable,
     reason,
@@ -18857,7 +20282,11 @@ function buildRouteBlock(env, provider, route, telemetry) {
     over_100k_share: total !== null && over !== null && total > 0 ? Math.round(over / total * 1e4) / 1e4 : null,
     advisor_calls: nN(telemetry?.advisor_calls),
     advisor_input_tokens: nN(telemetry?.advisor_input_tokens),
-    advisor_output_tokens: nN(telemetry?.advisor_output_tokens)
+    advisor_output_tokens: nN(telemetry?.advisor_output_tokens),
+    plan_model: s0(route?.["plan_model"]),
+    applied,
+    run_model: runModel ?? null,
+    not_proven: Array.isArray(route?.["route_not_proven"]) ? route["route_not_proven"].filter((x) => typeof x === "string") : []
   };
 }
 var over = (r, unit) => r.requests_total === null || r.requests_over_100k === null ? "not recorded" : `${r.requests_over_100k} of ${r.requests_total}${unit} (${pct(r)})`;
@@ -18876,119 +20305,154 @@ function routeReceiptLines(r) {
     `- Route shape_key: ${r.shape_key ?? "unknown"}  shape_parity: ${r.shape_parity}`,
     `- Route escalations: ${r.escalations.length === 0 ? "none" : r.escalations.map((e) => `${e.from} -> ${e.to} (${e.trigger}; evidence ${e.evidence})`).join("; ")}`,
     `- Route advisor: ${rec(r.advisor_calls)} calls, ${rec(r.advisor_input_tokens)} in / ${rec(r.advisor_output_tokens)} out tokens`,
-    ...r.units.map((u) => `- Route unit ${u.id}: executor ${u.executor}, assigned by ${u.assigned_by}: ${u.reason}; escalation: ${u.escalations.length === 0 ? "none" : u.escalations.map((e) => `${e.from} -> ${e.to} (${e.trigger})`).join(", ")}`),
+    ...r.units.map((u) => `- Route unit ${u.id}: executor ${u.applied ? u.executor : `not applied (assigned ${u.executor})`}, assigned by ${u.assigned_by}: ${u.reason}; escalation: ${u.escalations.length === 0 ? "none" : u.escalations.map((e) => `${e.from} -> ${e.to} (${e.trigger})`).join(", ")}`),
     `- Route requests over 100K: ${over(r, "")}`
   ];
 }
 function routeNotProven(r) {
   return [
     ...r.advisor_unavailable_reason ? [`advisor: NOT PROVEN (owner provider): ${r.advisor_unavailable_reason}`] : [],
-    `route.shape_parity: ${r.shape_parity}`
+    `route.shape_parity: ${r.shape_parity}`,
+    ...r.applied ? [] : [`route.executor: NOT PROVEN (owner engine): per-unit executor assignment is not applied (R1-11); every stage ran ${r.run_model ?? "the run model"}`],
+    ...r.not_proven
   ];
 }
 
-// ../../loki-ts/src/engine10/cost.ts
-import { mkdirSync as mkdirSync8, readdirSync as readdirSync10, readFileSync as readFileSync23, writeFileSync as writeFileSync11 } from "fs";
-import { join as join33 } from "path";
-var UNMETERED = "cli-invoker-unmetered";
-function routerTelemetryOn(env = process.env) {
-  return routerEnabled(env);
+// ../../loki-ts/src/runner/router/route_record.ts
+import { existsSync as existsSync25, lstatSync as lstatSync10, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync15 } from "fs";
+import { join as join44 } from "path";
+var ROUTE_RECORD_FILE = "route.json";
+function loadRouteRecord(runDir) {
+  try {
+    const p = join44(runDir, ROUTE_RECORD_FILE);
+    if (!existsSync25(p) || !lstatSync10(p).isFile())
+      return;
+    const v = JSON.parse(readFileSync30(p, "utf8"));
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
+  } catch {
+    return;
+  }
 }
-function num3(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+
+// ../../loki-ts/src/runner/router/history.ts
+import { dirname as dirname18, join as join45, resolve as resolve11 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// ../../loki-ts/src/runner/router/history_store.ts
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync31, renameSync as renameSync6, rmSync as rmSync11, writeFileSync as writeFileSync16 } from "fs";
+import { resolve as resolve10 } from "path";
+var HISTORY_FILE = "router_history.json";
+var HISTORY_CAP = 200;
+var EXECUTORS = ["haiku", "sonnet"];
+var VERDICTS = ["pass", "fail", "error", "not_proven"];
+var OWNERS = ["code", "harness", "env", "provider"];
+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 resultCostPath(lokiRoot, iteration) {
-  return join33(lokiRoot, "metrics", `result-cost-${iteration}.json`);
+function historyPath(key, cacheRoot) {
+  return resolve10(repoCacheDir(key, cacheRoot), HISTORY_FILE);
 }
-function sumResultCosts(lokiRoot, iterations) {
-  const out2 = {
-    usd: null,
-    partialUsd: 0,
-    measuredCount: 0,
-    totalCount: iterations.length,
-    input_tokens: 0,
-    output_tokens: 0,
-    cache_read_tokens: 0,
-    cache_creation_tokens: 0,
-    ...routerTelemetryOn() ? { router: {
-      requests_total: 0,
-      requests_over_100k: 0,
-      over_100k_input_tokens: 0,
-      over_100k_output_tokens: 0,
-      advisor_calls: 0,
-      advisor_input_tokens: 0,
-      advisor_output_tokens: 0
-    } } : {},
-    model: null,
-    source: "",
-    missing: []
-  };
-  const sources2 = [];
-  let usd = 0;
-  for (const iter of iterations) {
-    const path = resultCostPath(lokiRoot, iter);
-    let rec2;
+function readRunHistory(key, cacheRoot) {
+  const path = historyPath(key, cacheRoot);
+  if (!existsSync26(path))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync31(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);
+    mkdirSync15(repoCacheDir(key, cacheRoot), { recursive: true });
+    const target = historyPath(key, cacheRoot);
+    const tmp = `${target}.${process.pid}.tmp`;
     try {
-      rec2 = JSON.parse(readFileSync23(path, "utf8"));
-    } catch {
-      out2.missing.push(iter);
-      continue;
-    }
-    const inTok = num3(rec2["input_tokens"]);
-    const outTok = num3(rec2["output_tokens"]);
-    const cacheR = num3(rec2["cache_read_tokens"]);
-    const cacheC = num3(rec2["cache_creation_tokens"]);
-    out2.input_tokens += inTok;
-    out2.output_tokens += outTok;
-    out2.cache_read_tokens += cacheR;
-    out2.cache_creation_tokens += cacheC;
-    if (out2.router)
-      out2.router["requests_total"] += num3(rec2["requests_total"]);
-    if (out2.router)
-      out2.router["requests_over_100k"] += num3(rec2["requests_over_100k"]);
-    if (out2.router)
-      out2.router["over_100k_input_tokens"] += num3(rec2["over_100k_input_tokens"]);
-    if (out2.router)
-      out2.router["over_100k_output_tokens"] += num3(rec2["over_100k_output_tokens"]);
-    if (out2.router)
-      out2.router["advisor_calls"] += num3(rec2["advisor_calls"]);
-    if (out2.router)
-      out2.router["advisor_input_tokens"] += num3(rec2["advisor_input_tokens"]);
-    if (out2.router)
-      out2.router["advisor_output_tokens"] += num3(rec2["advisor_output_tokens"]);
-    if (typeof rec2["model"] === "string" && rec2["model"])
-      out2.model = rec2["model"];
-    sources2.push(path);
-    const c = rec2["total_cost_usd"];
-    const unmetered = rec2["source"] === UNMETERED;
-    if (unmetered)
-      out2.unmetered = true;
-    const noUsage = !unmetered && inTok === 0 && outTok === 0 && cacheR === 0 && cacheC === 0;
-    if (typeof c !== "number" || !Number.isFinite(c) || noUsage) {
-      out2.missing.push(iter);
-      continue;
+      writeFileSync16(tmp, JSON.stringify({ runs: runs2 }));
+      renameSync6(tmp, target);
+    } catch (e) {
+      rmSync11(tmp, { force: true, recursive: false });
+      throw e;
     }
-    usd += c;
-    out2.partialUsd += c;
-    out2.measuredCount++;
+    return true;
+  } catch {
+    return false;
+  }
+}
+// ../../loki-ts/src/runner/router/history.ts
+var SHAPE_DEFAULTS_FILE = resolve11(dirname18(fileURLToPath3(import.meta.url)), "..", "..", "..", "data", "router-shape-defaults.json");
+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;
   }
-  out2.source = sources2.join(",");
-  if (iterations.length > 0 && out2.missing.length === 0)
-    out2.usd = usd;
-  return out2;
 }
 
-// ../../loki-ts/src/util/check_result.ts
-var NO_TESTS_REASON = "no tests executed";
-var UNCONFIRMED_REASON = "test count could not be confirmed";
-var UNMEASURED_REASON = "executed count unmeasured (Loki could not parse the runner summary, harness-owned)";
-var isExecutedProof = (c) => c.result === "pass" && typeof c.n === "number" && c.n > 0;
-var hasExecutedProof = (checks) => checks.some(isExecutedProof);
+// ../../loki-ts/src/util/engine_origin.ts
+function readOriginUrl(repoDir) {
+  try {
+    const url = safeGit(repoDir, ["config", "--get", "remote.origin.url"]).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../loki-ts/src/runner/router/cost_preview.ts
+var NOT_RECORDED = "NOT RECORDED";
+var previewOn = (env) => env["LOKI_COST_PREVIEW"] !== "0";
+function receiptBlock(env, usd, unmetered, wallS) {
+  if (!previewOn(env))
+    return {};
+  let r = { ok: false, reason: "no estimate carried from the run start" };
+  try {
+    const raw2 = env["LOKI_E10_COST_ESTIMATE"];
+    if (raw2)
+      r = JSON.parse(raw2);
+  } catch {}
+  const source = r.ok === true ? "history" : r.prior ? "rough_prior" : null;
+  return { cost_preview: {
+    ...source ? { estimate_source: source } : {},
+    estimate: !r.ok && r.prior ? { usd_low: r.prior.usd[0], usd_high: r.prior.usd[1], tier: r.prior.tier, size_class: r.prior.size_class } : r.ok === true ? { usd_low: r.est.usd[0], usd_high: r.est.usd[1], wall_low_s: r.est.wall_s[0], wall_high_s: r.est.wall_s[1], prior_runs: r.est.runs, shape: r.est.shape } : `NOT AVAILABLE (${r.reason ?? "unreadable estimate"})`,
+    actual: { usd: usd === null || unmetered ? NOT_RECORDED : usd, wall_s: wallS === null || wallS <= 0 ? NOT_RECORDED : wallS }
+  } };
+}
+function recordRun(env, repoDir, model, verdict, usd, unmetered, wallS, cacheRoot) {
+  if (!previewOn(env) || verdict !== "VERIFIED" || usd === null || unmetered || wallS <= 0)
+    return false;
+  const shape = shapeKeyForRepo(repoDir);
+  if (shape === null)
+    return false;
+  return appendRunOutcome(repoKey(readOriginUrl(repoDir), repoDir), { shape, executor: /haiku/i.test(model) ? "haiku" : "sonnet", verdict: "pass", owner: null, escalated: false, usd, wallS }, cacheRoot);
+}
+
+// ../../loki-ts/src/engine10/stages/seal.ts
+init_cost();
 
 // ../../loki-ts/src/features/contract.ts
-import { existsSync as existsSync19, lstatSync as lstatSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname11, join as join34 } from "path";
-import { createHash as createHash7 } from "crypto";
+import { existsSync as existsSync27, lstatSync as lstatSync11, mkdirSync as mkdirSync16, readFileSync as readFileSync32, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname19, join as join46 } from "path";
+import { createHash as createHash9 } from "crypto";
 var MAX_CRITERIA = 50;
 var MAX_TEXT = 500;
 function contractEnabled(env = process.env) {
@@ -19002,11 +20466,11 @@ function overlaps(criterionWords, target) {
   const tw = new Set(words(target));
   return criterionWords.some((w) => tw.has(w) || w.length > 4 && w.endsWith("s") && tw.has(w.slice(0, -1)));
 }
-function traceContract(contract, changedFiles, checkNames) {
+function traceContract(contract, changedFiles2, checkNames) {
   return {
     criteria: contract.criteria.map((c) => {
       const cw = words(c.text);
-      const files = changedFiles.filter((f) => overlaps(cw, f));
+      const files = changedFiles2.filter((f) => overlaps(cw, f));
       const checks = checkNames.filter((n2) => overlaps(cw, n2));
       const traced = files.length > 0;
       return { id: c.id, text: c.text, files, checks: traced ? checks : [], status: traced ? "keyword_match" : "no_match" };
@@ -19022,14 +20486,14 @@ 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 join34(repoDir, ".loki", "contract.json");
+  return join46(repoDir, ".loki", "contract.json");
 }
 var MAX_CONTRACT_BYTES = 1024 * 1024;
 function readContract(repoDir) {
   const p = contractPath(repoDir);
   let st;
   try {
-    st = lstatSync8(p);
+    st = lstatSync11(p);
   } catch {
     return { contract: null, notes: [], sha256: null };
   }
@@ -19039,19 +20503,19 @@ function readContract(repoDir) {
     return { contract: null, notes: ["contract unreadable: too large"], sha256: null };
   let raw2;
   try {
-    raw2 = readFileSync24(p);
+    raw2 = readFileSync32(p);
   } catch {
     return { contract: null, notes: ["contract unreadable: read failed"], sha256: null };
   }
-  const sha2562 = createHash7("sha256").update(raw2).digest("hex");
+  const sha2563 = createHash9("sha256").update(raw2).digest("hex");
   let j;
   try {
     j = JSON.parse(raw2.toString("utf8"));
   } catch {
-    return { contract: null, notes: ["contract unreadable: invalid JSON"], sha256: sha2562 };
+    return { contract: null, notes: ["contract unreadable: invalid JSON"], sha256: sha2563 };
   }
   if (!Array.isArray(j?.criteria))
-    return { contract: null, notes: [], sha256: sha2562 };
+    return { contract: null, notes: [], sha256: sha2563 };
   const criteria = [];
   let malformed = 0;
   for (const c of j.criteria) {
@@ -19065,7 +20529,7 @@ function readContract(repoDir) {
     criteria.push({ id: o.id.slice(0, 40), text: o.text.slice(0, MAX_TEXT), source_line: typeof o.source_line === "number" ? o.source_line : 0 });
   }
   const notes = malformed > 0 ? [`contract: ${malformed} malformed criteria dropped`] : [];
-  return { contract: { source: typeof j.source === "string" ? j.source : "", criteria }, notes, sha256: sha2562 };
+  return { contract: { source: typeof j.source === "string" ? j.source : "", criteria }, notes, sha256: sha2563 };
 }
 function sealContract(repoDir, body, rawDiff, checks, env = process.env, snap) {
   if (!contractEnabled(env))
@@ -19074,7 +20538,7 @@ function sealContract(repoDir, body, rawDiff, checks, env = process.env, snap) {
     const live2 = readContract(repoDir);
     let exists2 = true;
     try {
-      lstatSync8(contractPath(repoDir));
+      lstatSync11(contractPath(repoDir));
     } catch {
       exists2 = false;
     }
@@ -19102,33 +20566,33 @@ function sealContract(repoDir, body, rawDiff, checks, env = process.env, snap) {
 }
 
 // ../../loki-ts/src/features/speed/seal_group.ts
-import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync20, readdirSync as readdirSync11, readFileSync as readFileSync25, statSync as statSync12 } from "fs";
-import { dirname as dirname12, join as join35 } from "path";
+import { createHash as createHash10 } from "crypto";
+import { existsSync as existsSync28, readdirSync as readdirSync13, readFileSync as readFileSync33, statSync as statSync13 } from "fs";
+import { dirname as dirname20, join as join47 } from "path";
 var ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 var PASSING = new Set(["VERIFIED", "ALREADY_SATISFIED"]);
-var sha2 = (b) => createHash8("sha256").update(b).digest("hex");
+var sha2 = (b) => createHash10("sha256").update(b).digest("hex");
 var isObj10 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 var text2 = (v, cap) => typeof v === "string" ? v.replace(/[\x00-\x1f\x7f]+/g, " ").trim().slice(0, cap) : "";
 var num4 = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
-var unitsDir = (runDir) => join35(runDir, "group", "units");
+var unitsDir = (runDir) => join47(runDir, "group", "units");
 var readJson3 = (p) => {
   try {
-    return JSON.parse(readFileSync25(p, "utf8"));
+    return JSON.parse(readFileSync33(p, "utf8"));
   } catch {
     return;
   }
 };
 var dirNames = (d) => {
   try {
-    return readdirSync11(d).filter((n2) => !n2.startsWith(".")).sort();
+    return readdirSync13(d).filter((n2) => !n2.startsWith(".")).sort();
   } catch {
     return null;
   }
 };
 function sealGroup(runDir, rh) {
-  const manifestPath = join35(runDir, "group", "manifest.json");
-  if (!existsSync20(manifestPath))
+  const manifestPath = join47(runDir, "group", "manifest.json");
+  if (!existsSync28(manifestPath))
     return { section: undefined, notProven: [], problems: 0, allUnitsPass: true };
   const notProven = [];
   let problems = 0;
@@ -19152,10 +20616,10 @@ function sealGroup(runDir, rh) {
       return fail(`unit ${index2} has an invalid, duplicate or case-colliding id`);
     seen.add(id);
     seenLower.add(id.toLowerCase());
-    const dir = join35(unitsDir(runDir), id), rp = join35(dir, "receipt.json"), ep = join35(dir, "events.jsonl");
+    const dir = join47(unitsDir(runDir), id), rp = join47(dir, "receipt.json"), ep = join47(dir, "events.jsonl");
     let bytes;
     try {
-      bytes = readFileSync25(rp);
+      bytes = readFileSync33(rp);
     } catch {
       return fail(`unit ${id} sub-receipt missing`);
     }
@@ -19172,7 +20636,7 @@ function sealGroup(runDir, rh) {
       unit_id: id,
       sub_receipt_sha256: sha2(bytes),
       receipt_sha256: sub["receipt_sha256"],
-      events_file_sha256: existsSync20(ep) ? sha2(readFileSync25(ep)) : null,
+      events_file_sha256: existsSync28(ep) ? sha2(readFileSync33(ep)) : null,
       verdict,
       goal: text2(u["goal"], 200),
       files: (Array.isArray(u["files"]) ? u["files"] : []).map((f) => text2(f, 200)).filter(Boolean).slice(0, 50),
@@ -19192,12 +20656,12 @@ function capGroupVerdict(v, g) {
   return !g.allUnitsPass && (v === "VERIFIED" || v === "ALREADY_SATISFIED") ? "PARTIAL" : v;
 }
 async function verifyGroup(receiptPath, receipt, rh, verifyOne, deps = {}) {
-  const runDir = dirname12(receiptPath);
+  const runDir = dirname20(receiptPath);
   const signed = isObj10(receipt["verification"]) && typeof receipt["verification"]["jwt"] === "string";
   const bad = (reason) => ({ verdict: "TAMPERED", reason: `group: ${reason}` });
   const g = receipt["group"];
   if (g === undefined)
-    return existsSync20(join35(runDir, "group", "manifest.json")) ? bad("group directory present but the receipt has no group section") : null;
+    return existsSync28(join47(runDir, "group", "manifest.json")) ? bad("group directory present but the receipt has no group section") : null;
   if (!isObj10(g) || !ID_RE.test(String(g["group_id"] ?? "")) || !Array.isArray(g["units"]) || g["units"].length === 0)
     return bad("group section malformed");
   const entries = g["units"];
@@ -19209,20 +20673,20 @@ async function verifyGroup(receiptPath, receipt, rh, verifyOne, deps = {}) {
     return bad("unit directories do not match the receipt (missing or extra unit)");
   let unchecked = null;
   for (let i = 0;i < entries.length; i++) {
-    const e = entries[i], id = ids[i], dir = join35(unitsDir(runDir), id), rp = join35(dir, "receipt.json"), ep = join35(dir, "events.jsonl");
+    const e = entries[i], id = ids[i], dir = join47(unitsDir(runDir), id), rp = join47(dir, "receipt.json"), ep = join47(dir, "events.jsonl");
     if (e["index"] !== i)
       return bad(`unit ${id} is out of order (index ${String(e["index"])} at position ${i})`);
     let bytes;
     try {
-      if (!statSync12(dir).isDirectory())
+      if (!statSync13(dir).isDirectory())
         return bad(`unit ${id} is not a directory`);
-      bytes = readFileSync25(rp);
+      bytes = readFileSync33(rp);
     } catch {
       return bad(`unit ${id} sub-receipt missing`);
     }
     if (sha2(bytes) !== e["sub_receipt_sha256"])
       return bad(`unit ${id} sub-receipt does not match its recorded hash`);
-    const evSha = existsSync20(ep) ? sha2(readFileSync25(ep)) : null;
+    const evSha = existsSync28(ep) ? sha2(readFileSync33(ep)) : null;
     if (evSha !== (e["events_file_sha256"] ?? null))
       return bad(`unit ${id} events.jsonl does not match its recorded hash`);
     const sub = readJson3(rp);
@@ -19241,11 +20705,263 @@ async function verifyGroup(receiptPath, receipt, rh, verifyOne, deps = {}) {
   return unchecked ? { verdict: "UNCHECKED", reason: `group: ${unchecked}` } : null;
 }
 
+// ../../loki-ts/src/supply/supply_guard.ts
+init_shell();
+import { existsSync as existsSync29, readFileSync as readFileSync34, statSync as statSync14 } from "fs";
+import { basename as basename16, join as join48 } from "path";
+var MIN_AGE_DAYS = 7;
+var DECLARED_FILE = "supply-declared.json";
+var MAX_CHECKED = 50;
+var MAX_DECLARED = 200;
+var MAX_FILE_BYTES = 64 * 1024;
+var DAY_MS = 86400000;
+var MANIFESTS = /^(package\.json|package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?|requirements.*\.txt|pyproject\.toml|poetry\.lock|uv\.lock|Pipfile|Pipfile\.lock|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|Gemfile|Gemfile\.lock|composer\.json|composer\.lock|pom\.xml|build\.gradle(\.kts)?)$/;
+function supplyEnabled(env) {
+  return env["LOKI_SUPPLY_GUARD"] !== "0";
+}
+function failAgeDays(env) {
+  const n2 = Number(env["LOKI_SUPPLY_MIN_AGE_DAYS"]);
+  return Number.isFinite(n2) && n2 > 0 ? n2 : null;
+}
+function supplyVerdict(verdict, r) {
+  return r.blocked && verdict === "VERIFIED" ? "FAILED" : verdict;
+}
+function isManifestPath(path) {
+  return MANIFESTS.test(basename16(path));
+}
+var ECO = { npm: "npm", node: "npm", pypi: "pypi", pip: "pypi", python: "pypi", cargo: "cargo", crates: "cargo", go: "go", golang: "go" };
+var NAME2 = /^[A-Za-z0-9@][A-Za-z0-9@._/~+-]{0,213}$/;
+function readDeclared(repoDir) {
+  const p = join48(repoDir, ".loki", DECLARED_FILE);
+  if (!existsSync29(p))
+    return { deps: [], problem: null };
+  try {
+    if (statSync14(p).size > MAX_FILE_BYTES)
+      return { deps: [], problem: "declaration file too large" };
+    const j = JSON.parse(readFileSync34(p, "utf8"));
+    if (!Array.isArray(j))
+      return { deps: [], problem: "declaration is not a JSON array" };
+    const deps = [];
+    for (const o of j.slice(0, MAX_DECLARED)) {
+      if (!o || typeof o !== "object")
+        continue;
+      const r = o;
+      const eco = ECO[String(r["ecosystem"] ?? "").toLowerCase()] ?? String(r["ecosystem"] ?? "").toLowerCase().slice(0, 30);
+      const name = String(r["name"] ?? "");
+      if (!eco || !NAME2.test(name))
+        continue;
+      deps.push({ ecosystem: eco, name, version_spec: String(r["version_spec"] ?? "").slice(0, 100), registry: String(r["registry"] ?? "default").slice(0, 200) });
+    }
+    return { deps, problem: null };
+  } catch {
+    return { deps: [], problem: "declaration unreadable" };
+  }
+}
+function readAllowlist(repoDir) {
+  const p = join48(repoDir, ".loki", "supply-allowlist");
+  if (!existsSync29(p))
+    return new Set;
+  try {
+    return new Set(readFileSync34(p, "utf8").split(`
+`).map((l) => l.replace(/#.*$/, "").trim()).filter(Boolean));
+  } catch {
+    return new Set;
+  }
+}
+function classify2(eco, name, exitCode, stdout, stderr) {
+  const err = `${stderr}
+${stdout}`;
+  if (eco === "npm") {
+    if (exitCode === 0) {
+      const m = /"?(\d{4}-\d\d-\d\dT[\d:.]+Z)"?/.exec(stdout);
+      return m ? { status: "exists", firstPublish: Date.parse(m[1]) } : { status: "exists" };
+    }
+    return /E404|404 Not Found|is not in this registry/i.test(err) ? { status: "missing" } : { status: "unproven" };
+  }
+  if (eco === "pypi") {
+    if (exitCode === 0)
+      return /Available versions/i.test(stdout) ? { status: "exists" } : { status: "unproven" };
+    return /No matching distribution|from versions: none/i.test(err) ? { status: "missing" } : { status: "unproven" };
+  }
+  if (eco === "cargo") {
+    if (exitCode !== 0)
+      return { status: "unproven" };
+    const norm3 = (x) => x.toLowerCase().replace(/_/g, "-");
+    return stdout.split(`
+`).some((l) => norm3(l).startsWith(`${norm3(name)} = `)) ? { status: "exists" } : { status: "missing" };
+  }
+  if (eco === "go") {
+    if (exitCode === 0)
+      return { status: "exists" };
+    return /no matching versions|not found|404|410/i.test(err) && !/dial tcp|timeout|no such host|connection/i.test(err) ? { status: "missing" } : { status: "unproven" };
+  }
+  return { status: "unproven" };
+}
+var defaultResolver = async (dep, cwd) => {
+  const argv = {
+    npm: ["npm", "view", dep.name, "time.created", "--json"],
+    pypi: ["pip", "index", "versions", "--pre", "--ignore-requires-python", dep.name],
+    cargo: ["cargo", "search", dep.name, "--limit", "5"],
+    go: ["go", "list", "-m", "-json", `${dep.name}@latest`]
+  };
+  const cmd = argv[dep.ecosystem];
+  if (!cmd || dep.name.startsWith("-"))
+    return { status: "unproven" };
+  try {
+    const r = await run(cmd, { cwd, timeoutMs: 1e4 });
+    return classify2(dep.ecosystem, dep.name, r.exitCode, r.stdout, r.stderr);
+  } catch {
+    return { status: "unproven" };
+  }
+};
+var PUBLIC_HOSTS = new Set(["registry.npmjs.org", "registry.npmjs.com", "registry.yarnpkg.com", "npmjs.com", "npmjs.org", "pypi.org", "pypi.python.org", "files.pythonhosted.org", "crates.io", "index.crates.io", "static.crates.io", "proxy.golang.org", "golang.org", "pkg.go.dev"]);
+var hostOf = (u) => u.trim().toLowerCase().replace(/^[a-z][a-z0-9+.-]*:\/\//, "").replace(/^www\./, "").split(/[/?#\s]/)[0].replace(/^[^@]*@/, "").replace(/:\d+$/, "");
+var privateUrl = (u) => /[a-z0-9]/i.test(u) && !PUBLIC_HOSTS.has(hostOf(u));
+var readSmall = (p) => {
+  try {
+    return statSync14(p).size <= MAX_FILE_BYTES ? readFileSync34(p, "utf8") : "";
+  } catch {
+    return "";
+  }
+};
+function userConfigPrivate(eco, repoDir, env, goEnv = {}, name = "") {
+  const home = env["HOME"] ?? "";
+  const files = (...p) => p.filter((x) => x !== "").map((x) => readSmall(x));
+  if (eco === "npm") {
+    if (privateUrlList([env["npm_config_registry"] ?? "", env["NPM_CONFIG_REGISTRY"] ?? ""]))
+      return true;
+    return files(join48(repoDir, ".npmrc"), home ? join48(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]}/`));
+    }));
+  }
+  if (eco === "pypi") {
+    if (privateUrlList([env["PIP_INDEX_URL"] ?? "", env["PIP_EXTRA_INDEX_URL"] ?? ""]))
+      return true;
+    const cfg = [env["PIP_CONFIG_FILE"] ?? "", home ? join48(home, ".config", "pip", "pip.conf") : "", home ? join48(home, ".pip", "pip.conf") : "", join48(repoDir, "pip.conf")];
+    return files(...cfg).some((t) => t.split(`
+`).some((l) => {
+      const m = /^\s*(?:extra-)?index-url\s*[=:]\s*(.+)$/.exec(l);
+      return !!m && m[1].split(/\s+/).some(privateUrl);
+    }));
+  }
+  if (eco === "cargo") {
+    if (Object.keys(env).some((k) => /^CARGO_REGISTRIES_.+_INDEX$/.test(k) || /^CARGO_SOURCE_/.test(k)))
+      return true;
+    return files(join48(repoDir, ".cargo", "config.toml"), join48(repoDir, ".cargo", "config"), home ? join48(home, ".cargo", "config.toml") : "", home ? join48(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"] ?? "";
+    return gp.split(/[,|]/).map((x) => x.trim()).filter((x) => x && x !== "direct" && x !== "off").some(privateUrl);
+  }
+  return false;
+}
+var privateUrlList = (v) => v.some((x) => x.split(/\s+/).some((u) => u !== "" && privateUrl(u)));
+function goPrivate(d, env) {
+  if (d.ecosystem !== "go")
+    return false;
+  const pats = `${env["GOPRIVATE"] ?? ""},${env["GONOPROXY"] ?? ""}`.split(",").map((x) => x.trim()).filter(Boolean);
+  const parts = d.name.split("/");
+  return pats.some((pat) => {
+    const n2 = pat.split("/").length;
+    const re = new RegExp(`^${pat.split("/").map((seg) => seg.replace(/[.+^${}()|\\[\]]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")).join("/")}$`);
+    return re.test(parts.slice(0, n2).join("/"));
+  });
+}
+async function readGoEnv(cwd) {
+  try {
+    const r = await run(["go", "env", "-json", "GOPRIVATE", "GONOPROXY", "GOPROXY"], { cwd, timeoutMs: 1e4 });
+    const j = JSON.parse(r.stdout);
+    return Object.fromEntries(Object.entries(j).map(([k, v]) => [k, String(v)]));
+  } catch {
+    return {};
+  }
+}
+var injected = null;
+async function supplyGuard(repoDir, changedFiles2, declared, env, opts = {}) {
+  const none = { block: null, notProven: [], blocked: false };
+  if (!supplyEnabled(env))
+    return none;
+  const touched = changedFiles2.filter(isManifestPath);
+  if (touched.length === 0)
+    return none;
+  const resolver = opts.resolver ?? injected ?? defaultResolver, now2 = opts.now ?? Date.now(), failAge = failAgeDays(env);
+  const goEnv = opts.goEnv ?? (declared.deps.some((x) => x.ecosystem === "go") && !opts.resolver && !injected ? await readGoEnv(repoDir) : {});
+  const notProven = [];
+  let blocked = false;
+  if (declared.problem)
+    notProven.push(`supply guard NOT PROVEN: ${declared.problem}`);
+  if (declared.deps.length === 0) {
+    if (!declared.problem)
+      notProven.push(`supply guard WARNING: dependencies changed (${[...new Set(touched)].slice(0, 5).join(", ")}) but none declared; not checked`);
+    return { block: { guard: "v2", warn_age_days: MIN_AGE_DAYS, fail_age_days: failAge, declared: 0, entries: [] }, notProven, blocked: false };
+  }
+  const allow = readAllowlist(repoDir), cache2 = new Map;
+  let checked = 0;
+  const entries = [];
+  for (const d of declared.deps) {
+    const base = { ecosystem: d.ecosystem, name: d.name, version_spec: d.version_spec, registry: d.registry };
+    if (!["npm", "pypi", "cargo", "go"].includes(d.ecosystem)) {
+      entries.push({ ...base, status: "unsupported" });
+      continue;
+    }
+    if (allow.has(d.name)) {
+      entries.push({ ...base, status: "allowlisted" });
+      continue;
+    }
+    if (++checked > MAX_CHECKED) {
+      entries.push({ ...base, status: "capped" });
+      continue;
+    }
+    const key = `${d.ecosystem}:${d.name}`;
+    let h = cache2.get(key);
+    if (!h) {
+      h = resolver(d, repoDir, env).catch(() => ({ status: "unproven" }));
+      cache2.set(key, h);
+    }
+    let res = await h;
+    if (res.status === "missing" && (userConfigPrivate(d.ecosystem, repoDir, env, goEnv, d.name) || goPrivate(d, { ...env, ...goEnv })))
+      res = { status: "unproven" };
+    if (res.status === "missing")
+      entries.push({ ...base, status: "nonexistent" });
+    else if (res.status === "unproven")
+      entries.push({ ...base, status: "unreachable" });
+    else if (res.firstPublish === undefined || !Number.isFinite(res.firstPublish))
+      entries.push({ ...base, status: "ok" });
+    else {
+      const age = Math.floor((now2 - res.firstPublish) / DAY_MS);
+      entries.push({ ...base, status: age < MIN_AGE_DAYS || failAge !== null && age < failAge ? "too_new" : "ok", age_days: age });
+    }
+  }
+  for (const e of entries) {
+    const id = `${e.ecosystem}:${e.name}`;
+    if (e.status === "nonexistent") {
+      blocked = true;
+      notProven.push(`supply guard FAILED: declared dependency ${id} does not resolve in the registry (possible hallucinated package)`);
+    } else if (e.status === "too_new") {
+      if (failAge !== null && (e.age_days ?? 0) < failAge) {
+        blocked = true;
+        notProven.push(`supply guard FAILED: ${id} first published ${e.age_days} days ago (LOKI_SUPPLY_MIN_AGE_DAYS=${failAge}); allowlist in .loki/supply-allowlist to accept`);
+      } else
+        notProven.push(`supply guard WARNING: ${id} first published ${e.age_days} days ago (under ${MIN_AGE_DAYS}); verdict unchanged`);
+    } else if (e.status === "unreachable")
+      notProven.push(`supply guard NOT PROVEN: resolver could not answer for ${id}`);
+    else if (e.status === "capped")
+      notProven.push(`supply guard: not checked: cap ${MAX_CHECKED} exceeded: ${id}`);
+    else if (e.status === "unsupported")
+      notProven.push(`supply guard: not checked (ecosystem unsupported in v1): ${id}`);
+    else if (e.status === "allowlisted")
+      notProven.push(`supply guard: allowlisted, not checked: ${id}`);
+  }
+  return { block: { guard: "v2", warn_age_days: MIN_AGE_DAYS, fail_age_days: failAge, declared: declared.deps.length, entries }, notProven, blocked };
+}
+
 // ../../loki-ts/src/engine10/stages/seal.ts
 var DEEP_NOT_PROVEN = ["full suite", "app boot", "council", "security scan"];
 var SIGNING_UNAVAILABLE = "receipt signing unavailable (no usable signing key: invalid key or unwritable ~/.loki/keys)";
 var EXCLUDE_LOKI = ":(exclude).loki";
-var sha2562 = (s) => createHash9("sha256").update(s).digest("hex");
+var sha2562 = (s) => createHash11("sha256").update(s).digest("hex");
 var str3 = (v) => typeof v === "string" && v !== "" ? v : null;
 var strs2 = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [];
 function sanitizeReason(s) {
@@ -19270,37 +20986,37 @@ function receiptSha256(r) {
   return sha2562(canonicalJson(body));
 }
 var b64u = (b) => Buffer.from(b).toString("base64url");
-var kidOf2 = (pub) => b64u(createHash9("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${pub.export({ format: "jwk" }).x}"}`).digest());
+var kidOf2 = (pub) => b64u(createHash11("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${pub.export({ format: "jwk" }).x}"}`).digest());
 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 || join36(process.env["HOME"] || homedir7(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
+      const file = given || join49(process.env["HOME"] || homedir8(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
       try {
-        pem = readFileSync26(file);
+        pem = readFileSync35(file);
         if (!given) {
-          for (const [f, m] of [[file, 384], [dirname13(file), 448]])
-            if (statSync13(f).mode & 63)
+          for (const [f, m] of [[file, 384], [dirname21(file), 448]])
+            if (statSync15(f).mode & 63)
               chmodSync5(f, m);
         }
       } catch (e) {
         if (e.code !== "ENOENT" || !generate)
           return null;
-        mkdirSync10(dirname13(dirname13(file)), { recursive: true, mode: 448 });
-        mkdirSync10(dirname13(file), { recursive: true, mode: 448 });
+        mkdirSync17(dirname21(dirname21(file)), { recursive: true, mode: 448 });
+        mkdirSync17(dirname21(file), { recursive: true, mode: 448 });
         const tmp = `${file}.${randomBytes3(6).toString("hex")}.tmp`;
-        writeFileSync13(tmp, generateKeyPairSync("ed25519").privateKey.export({ type: "pkcs8", format: "pem" }), { flag: "wx", mode: 384 });
+        writeFileSync18(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 {
-          unlinkSync4(tmp);
+          unlinkSync5(tmp);
         }
-        pem = readFileSync26(file);
+        pem = readFileSync35(file);
       }
     }
     const k = createPrivateKey(pem);
@@ -19317,37 +21033,37 @@ function signReceipt(runId, hash) {
   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 git(ctx, args) {
-  const r = await run(["git", ...args], { cwd: ctx.repoDir, timeoutMs: 20000 });
+async function git2(ctx, args, keep = {}) {
+  const r = await safeGitRun(ctx.repoDir, args, { timeoutMs: 20000, ...keep });
   return { out: r.stdout, code: r.exitCode };
 }
 var commitStage = {
   name: "commit",
   ...STAGE_BUDGETS.commit,
   async run(ctx) {
-    if (!ctx.baseSha || (await git(ctx, ["rev-parse", "--verify", "-q", `${ctx.baseSha}^{commit}`])).code !== 0)
+    if (!ctx.baseSha || (await git2(ctx, ["rev-parse", "--verify", "-q", `${ctx.baseSha}^{commit}`])).code !== 0)
       return { status: "failed", data: {}, reason: "base commit not resolvable" };
-    if ((await git(ctx, ["add", "-A", "--", "."])).code !== 0)
+    if ((await git2(ctx, ["add", "-A", "--", "."], { repoDrivers: true })).code !== 0)
       return { status: "failed", data: {}, reason: "git add failed" };
-    const sd = await git(ctx, ["diff", "--cached", "--name-status", "--no-renames", "-z", ctx.baseSha]);
+    const sd = await git2(ctx, ["diff", "--cached", "--name-status", "--no-renames", "-z", ctx.baseSha]);
     if (sd.code !== 0)
       return { status: "failed", data: {}, reason: "git diff against base failed" };
     const staged = parseStaged(sd.out);
     const drop = dropSet(ctx.repoDir, staged, ctx.outputs().intake?.preexisting_dirty);
-    const sat = await discardIfSatisfied((a) => git(ctx, a), ctx.baseSha, ctx.outputs(), staged, new Set(drop.filter(({ st }) => st === "L").map(({ f }) => f)), ctx.repoDir);
+    const sat = await discardIfSatisfied((a) => git2(ctx, a), ctx.baseSha, ctx.outputs(), staged, new Set(drop.filter(({ st }) => st === "L").map(({ f }) => f)), ctx.repoDir);
     if (sat)
       return sat;
-    if (drop.length > 0 && (await git(ctx, ["--literal-pathspecs", "reset", "-q", ctx.baseSha, "--", ...drop.map(({ f }) => f)])).code !== 0)
+    if (drop.length > 0 && (await git2(ctx, ["--literal-pathspecs", "reset", "-q", ctx.baseSha, "--", ...drop.map(({ f }) => f)])).code !== 0)
       return { status: "failed", data: {}, reason: "git reset failed" };
     const dropped2 = new Set(drop.map(({ f }) => f)), notes = flagOutsideScope(ctx.outputs(), staged.filter(({ f }) => !dropped2.has(f)));
-    if ((await git(ctx, ["diff", "--cached", "--quiet"])).code === 0)
+    if ((await git2(ctx, ["diff", "--cached", "--quiet"])).code === 0)
       return { status: "completed", data: { committed: false, scope_notes: notes } };
     const title = (str3(ctx.outputs().intake?.title) ?? `run ${ctx.runId}`).split(`
 `)[0].slice(0, 72);
-    const c = await git(ctx, ["commit", "-q", "-m", `loki: ${title}`, "-m", `Loki-Run: ${ctx.runId}`]);
+    const c = await git2(ctx, ["commit", "-q", "-m", `loki: ${title}`, "-m", `Loki-Run: ${ctx.runId}`], { repoDrivers: true, userHooks: true });
     if (c.code !== 0)
       return { status: "failed", data: {}, reason: "git commit failed" };
-    return { status: "completed", data: { committed: true, head_sha: (await git(ctx, ["rev-parse", "HEAD"])).out.trim(), scope_notes: notes } };
+    return { status: "completed", data: { committed: true, head_sha: (await git2(ctx, ["rev-parse", "HEAD"])).out.trim(), scope_notes: notes } };
   }
 };
 function verdictOf2(o, checks, emptyDiff, verifyNotProven, wallGreenOnBase, proof, targetProof = false, uncovered = []) {
@@ -19396,6 +21112,7 @@ function renderReceiptMd(r) {
     `- receipt_sha256: ${r.receipt_sha256}`,
     `- Signature: ${sig}`,
     `- Provider: ${r.provider} (${r.model})  Cost: ${usd}  Wall: ${r.time.wall_s}s`,
+    ...r.mutation_proof ? [`- ${r.mutation_proof}`] : [],
     ...r.route ? routeReceiptLines(r.route) : [],
     "",
     "### Checks",
@@ -19413,9 +21130,9 @@ var sealStage = {
   ...STAGE_BUDGETS.seal,
   async run(ctx, signal) {
     const o = ctx.outputs();
-    const head = (await git(ctx, ["rev-parse", "HEAD"])).out.trim();
-    const tree = (await git(ctx, ["rev-parse", "HEAD^{tree}"])).out.trim();
-    const diff = await run(["git", "diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-abbrev", "-O/dev/null", ctx.baseSha, head, "--", ".", EXCLUDE_LOKI], { cwd: ctx.repoDir, timeoutMs: 20000 });
+    const head = (await git2(ctx, ["rev-parse", "HEAD"])).out.trim();
+    const tree = (await git2(ctx, ["rev-parse", "HEAD^{tree}"])).out.trim();
+    const diff = await safeGitRun(ctx.repoDir, ["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-abbrev", "-O/dev/null", ctx.baseSha, head, "--", ".", EXCLUDE_LOKI], { timeoutMs: 20000 });
     const diffOk = diff.exitCode === 0 && /^[0-9a-f]{40,64}$/.test(head);
     const checks = checksOf(o.verify?.checks);
     const verifyNotProven = strs2(o.verify?.not_proven);
@@ -19432,8 +21149,12 @@ var sealStage = {
     const proof = wallGreenOnBase || hasExecutedProof(Array.isArray(o.verify?.checks) ? o.verify.checks : []);
     const uncoveredAfterLimit = o.implement?.exit === "killed" ? strs2(o.verify?.uncovered_changed) : [];
     const verdict0 = capGroupVerdict(verdictOf2(o, checks.filter((c) => !(c.result === "fail" && preRedChecks.includes(c.name))), !diffOk || diff.stdout === "", verifyNotProven.length > 0 || weakTests.length > 0, wallGreenOnBase, proof, targetProofOf(o.verify), uncoveredAfterLimit), grp);
-    const xr = await crossReview(ctx, verdict0, head), verdict = minVerdict(verdict0, xr);
-    const notProven = new Set([...DEEP_NOT_PROVEN, ...grp.notProven, ...xr?.notes ?? []]);
+    const supply = await supplyGuard(ctx.repoDir, rawDiff.filter((_, i) => i % 2 === 1), readDeclared(ctx.repoDir), process.env);
+    const verdict1 = supplyVerdict(verdict0, supply);
+    const xr = await crossReview(ctx, verdict1, head), verdict2 = minVerdict(verdict1, xr);
+    const mp = verdict2 === "VERIFIED" && mutationEnabled() ? mutationProof({ repoDir: ctx.repoDir, baseSha: ctx.baseSha, runDir: ctx.runDir, wallFiles: Array.isArray(o.wall?.files) ? o.wall.files : [], checks: Array.isArray(o.verify?.checks) ? o.verify.checks : [], runner: (ms) => new RealBaseTestRunner(undefined, ms) }) : null;
+    const verdict = mp?.outcome === "no" && mutationStrict() && o.plan?.behavior_change === true ? "PARTIAL" : verdict2;
+    const notProven = new Set([...DEEP_NOT_PROVEN, ...supply.notProven, ...grp.notProven, ...xr?.notes ?? []]);
     if (!proof && (verdict === "PARTIAL" || verdict === "VERIFIED" || verdict === "ALREADY_SATISFIED")) {
       const vc = Array.isArray(o.verify?.checks) ? o.verify.checks : [];
       notProven.add(vc.length > 0 && vc.every((c) => c.n !== 0 && String(c.reason ?? "").startsWith(UNMEASURED_REASON)) ? UNMEASURED_REASON : vc.length > 0 && vc.every((c) => c.n !== 0 && String(c.reason ?? "").startsWith(UNCONFIRMED_REASON)) ? UNCONFIRMED_REASON : NO_TESTS_REASON);
@@ -19444,8 +21165,8 @@ var sealStage = {
       notProven.add(`wall test discarded: ${String(d.file)} (${String(d.reason)})`);
     if (wallNotRun > 0) {
       try {
-        const kept = new Set((Array.isArray(o.wall?.files) ? o.wall.files : []).map((f) => basename11(String(f.path))));
-        for (const n2 of readdirSync12(join36(ctx.runDir, "wall")).sort())
+        const kept = new Set((Array.isArray(o.wall?.files) ? o.wall.files : []).map((f) => basename17(String(f.path))));
+        for (const n2 of readdirSync14(join49(ctx.runDir, "wall")).sort())
           if (!kept.has(n2))
             notProven.add(`wall test discarded: ${n2} (not_run)`);
       } catch {}
@@ -19494,6 +21215,8 @@ var sealStage = {
     if (source !== "text" && source !== "issue")
       notProven.add("task source not recorded by intake");
     const repo = str3(o.intake?.repo);
+    if (mp?.outcome === "no")
+      notProven.add(`Wall tests passed without the fix (mutation proof)${verdict !== verdict2 ? "; verdict downgraded to PARTIAL (LOKI_MUTATION_STRICT=1, declared behavior change)" : ""}`);
     if (repo === null)
       notProven.add("repo not recorded by intake");
     if (typeof o.intake?.resumed !== "boolean")
@@ -19508,12 +21231,12 @@ var sealStage = {
     const cost = ctx.cost.read(ctx.repoDir, iterIds);
     if (cost.unmetered)
       notProven.add("cost unmetered (CLI invoker; recorded as 0)");
-    const eventsPath = join36(ctx.runDir, "events.jsonl");
+    const eventsPath = join49(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, cost.router ?? (routerEnabled(process.env) ? sumResultCosts(join36(ctx.repoDir, ".loki"), iterIds).router : undefined));
+    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(join49(ctx.repoDir, ".loki"), iterIds).router : undefined), ctx.model);
     if (routeBlock)
       for (const l of routeNotProven(routeBlock))
         notProven.add(l);
@@ -19532,6 +21255,7 @@ var sealStage = {
       verdict,
       ...typeof o.implement?.limit_s === "number" ? { implement_limit: { limit_s: o.implement.limit_s, elapsed_s: typeof o.implement.elapsed_s === "number" ? o.implement.elapsed_s : 0 } } : {},
       ...grp.section ? { group: grp.section } : {},
+      ...ctx.failovers && ctx.failovers().length > 0 ? { failover: ctx.failovers() } : {},
       ...str3(o.implement?.spec_conflict_reason) !== null ? { spec_conflict_reason: sanitizeReason(str3(o.implement?.spec_conflict_reason)) } : {},
       evidence: strs2(o.intake?.evidence),
       ...o.intake?.preexisting_dirty ? { pre_existing_dirty: Object.keys(o.intake.preexisting_dirty) } : {},
@@ -19549,10 +21273,13 @@ var sealStage = {
       provider: ctx.provider,
       model: ctx.model,
       resumed: o.intake?.resumed === true,
-      events_sha256: sha2562(existsSync21(eventsPath) ? readFileSync26(eventsPath) : ""),
+      events_sha256: sha2562(existsSync30(eventsPath) ? readFileSync35(eventsPath) : ""),
       ...await sealEvidence(ctx.repoDir, ctx.runDir, o, notProven, signal, ctx.emit),
       log_seal: true,
-      ...routeBlock ? { route: routeBlock } : {}
+      ...receiptBlock(process.env, cost.usd, cost.unmetered === true, Object.values(stages).reduce((a, b) => a + (b ?? 0), 0)),
+      ...mp ? { mutation_proof: mp.line, mutation_outcome: mp.outcome } : {},
+      ...routeBlock ? { route: routeBlock } : {},
+      ...supply.block ? { supply: supply.block } : {}
     };
     for (const l of sealContract(ctx.repoDir, body, rawDiff, checks, process.env, o.intake?.contract_snapshot))
       notProven.add(l);
@@ -19564,13 +21291,17 @@ var sealStage = {
       hash = receiptSha256(body);
     }
     const receipt = { ...body, receipt_sha256: hash, verification: { jwt: sig.jwt, kid: sig.kid } };
-    mkdirSync10(ctx.runDir, { recursive: true });
-    const path = join36(ctx.runDir, "receipt.json");
-    writeFileSync13(path, JSON.stringify(receipt, null, 2) + `
+    mkdirSync17(ctx.runDir, { recursive: true });
+    const path = join49(ctx.runDir, "receipt.json");
+    writeFileSync18(path, JSON.stringify(receipt, null, 2) + `
 `);
-    writeFileSync13(join36(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
+    writeFileSync18(join49(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
+    recordRun(process.env, ctx.repoDir, ctx.model, verdict, cost.usd, cost.unmetered === true, receipt.time.wall_s);
     const signed = sig.jwt !== null;
-    const data = { receipt_path: path, receipt_sha256: hash, signed, kid: sig.kid, verdict, not_proven: receipt.not_proven, ...routeBlock ? { route_line: routePrLine(routeBlock) } : {} };
+    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) } : {} };
+    try {
+      recordRunVerdict(ctx.repoDir, ctx.runId, verdict);
+    } catch {}
     ctx.emit("receipt.sealed", "seal", { path, receipt_sha256: hash, signed, kid: sig.kid, verdict, not_proven: receipt.not_proven, ...routeBlock ? { route_line: routePrLine(routeBlock) } : {} });
     return { status: "completed", data: { ...data, summary: `${verdict} receipt ${hash.slice(0, 12)} ${signed ? `SIGNED kid ${sig.kid}` : "UNSIGNED"}` } };
   }
@@ -19578,7 +21309,7 @@ var sealStage = {
 
 // ../../loki-ts/src/features/receipt_dsse.ts
 import { createPublicKey as createPublicKey3, sign as sign2, verify as verify2 } from "crypto";
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync36 } from "fs";
 var DSSE_PAYLOAD_TYPE = "application/vnd.in-toto+json";
 var STATEMENT_TYPE = "https://in-toto.io/Statement/v1";
 var PREDICATE_TYPE = "https://autonomi.dev/loki/receipt/v10";
@@ -19659,7 +21390,7 @@ function verifyDsseReceipt(env, d) {
 }
 function runIdGuard(receiptPath, runId) {
   try {
-    return envelopeRunIdProblem(JSON.parse(readFileSync27(receiptPath, "utf8")), runId);
+    return envelopeRunIdProblem(JSON.parse(readFileSync36(receiptPath, "utf8")), runId);
   } catch {
     return null;
   }
@@ -19673,7 +21404,7 @@ function pubFor(kid, given) {
   const active = loadSigningKey(false);
   const pubs = (process.env["LOKI_RECEIPT_RETIRED_PUBKEYS"] ?? "").split(":").map((f) => f.trim()).filter(Boolean).flatMap((f) => {
     try {
-      return [createPublicKey4(readFileSync28(f))];
+      return [createPublicKey4(readFileSync37(f))];
     } catch {
       return [];
     }
@@ -19703,18 +21434,18 @@ function checkAttestation(jwt, expectedHash, given) {
 }
 function checkEventLog(receiptPath, receipt) {
   const bound = receipt["events_sha256"];
-  if (typeof bound !== "string" || bound === createHash10("sha256").digest("hex"))
+  if (typeof bound !== "string" || bound === createHash12("sha256").digest("hex"))
     return null;
-  const path = join37(dirname14(receiptPath), "events.jsonl");
-  if (!existsSync22(path))
+  const path = join50(dirname22(receiptPath), "events.jsonl");
+  if (!existsSync31(path))
     return "events.jsonl is missing";
-  const raw2 = readFileSync28(path, "utf8"), events2 = readEvents(path), lines = raw2.split(`
+  const raw2 = readFileSync37(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 = createHash10("sha256");
+  const h = createHash12("sha256");
   for (const l of lines) {
     if (h.copy().digest("hex") === bound)
       return null;
@@ -19724,7 +21455,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 = join37(dirname14(receiptPath), "events.jsonl"), events2 = readEvents(path), done = events2.findIndex((e) => e.type === "run.completed");
+  const path = join50(dirname22(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)
@@ -19732,8 +21463,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 = readFileSync28(path, "utf8").split(`
-`).filter((l) => l.trim() !== ""), sha3 = createHash10("sha256").update(lines.slice(0, done + 1).join(`
+  const lines = readFileSync37(path, "utf8").split(`
+`).filter((l) => l.trim() !== ""), sha3 = createHash12("sha256").update(lines.slice(0, done + 1).join(`
 `) + `
 `).digest("hex");
   const pub = d["kid"] === kid ? pubFor(kid, given) : undefined;
@@ -19742,11 +21473,11 @@ function checkLogSeal(receiptPath, hash, kid, given) {
   return null;
 }
 async function verifyReceipt(receiptPath, deps = {}) {
-  if (!existsSync22(receiptPath))
+  if (!existsSync31(receiptPath))
     return { verdict: "UNCHECKED", reasons: [`receipt not found: ${receiptPath}`] };
   let receipt;
   try {
-    receipt = JSON.parse((deps.read ?? ((p) => readFileSync28(p, "utf8")))(receiptPath));
+    receipt = JSON.parse((deps.read ?? ((p) => readFileSync37(p, "utf8")))(receiptPath));
   } catch {
     return { verdict: "UNCHECKED", reasons: ["receipt.json is not valid JSON"] };
   }
@@ -19814,11 +21545,11 @@ function mount21(ctx) {
       return done(404, "receipt not available", "not_found");
     let runDir, file;
     try {
-      const root = realpathSync17(join38(repo.p, ".loki", "runs"));
-      runDir = realpathSync17(join38(root, run2));
-      if (runDir !== join38(root, run2))
+      const root = realpathSync20(join51(repo.p, ".loki", "runs"));
+      runDir = realpathSync20(join51(root, run2));
+      if (runDir !== join51(root, run2))
         return done(404, "receipt not found", "not_found");
-      file = realpathSync17(join38(runDir, "receipt.json"));
+      file = realpathSync20(join51(runDir, "receipt.json"));
     } catch {
       return done(404, "receipt not found", "not_found");
     }
@@ -19837,7 +21568,7 @@ function mount21(ctx) {
         sha3 = r.receiptSha256 ?? null;
       }
       try {
-        outcome = outcomeOf(JSON.parse(readFileSync29(file, "utf8")));
+        outcome = outcomeOf(JSON.parse(readFileSync38(file, "utf8")));
       } catch {
         outcome = "UNREADABLE";
       }
@@ -19899,8 +21630,8 @@ function ttlCache(ttlMs = PROBE_CACHE_MS, now2 = Date.now) {
 }
 
 // src/server/legacy/shim.ts
-import { existsSync as existsSync23, readFileSync as readFileSync30 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync39 } from "fs";
+import { join as join52 } from "path";
 
 // src/server/legacy/routes.ts
 var LEGACY_ROUTES = [
@@ -20272,10 +22003,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 [join39(import.meta.dir, "../../../../../VERSION")]) {
+  for (const f of [join52(import.meta.dir, "../../../../../VERSION")]) {
     try {
-      if (existsSync23(f))
-        return readFileSync30(f, "utf8").trim();
+      if (existsSync32(f))
+        return readFileSync39(f, "utf8").trim();
     } catch {}
   }
   return "unknown";
@@ -20457,7 +22188,7 @@ function legacyShim(opts) {
 
 // src/server/app.ts
 var MAX_BODY2 = 1e6;
-var defaultUiDir = () => [join40(import.meta.dir, "../../ui/dist"), join40(import.meta.dir, "../ui/dist")].find((d) => existsSync24(join40(d, "index.html")));
+var defaultUiDir = () => [join53(import.meta.dir, "../../ui/dist"), join53(import.meta.dir, "../ui/dist")].find((d) => existsSync33(join53(d, "index.html")));
 function createApp(opts) {
   const uiDir = opts.uiDir ?? defaultUiDir();
   const { db, sqlite } = openDb(opts.dbPath);
@@ -20486,10 +22217,10 @@ function createApp(opts) {
     await next();
   });
   const readInstalled = () => {
-    for (const f of [process.env.LOKI_VERSION_FILE, join40(import.meta.dir, "../../../../VERSION")]) {
+    for (const f of [process.env.LOKI_VERSION_FILE, join53(import.meta.dir, "../../../../VERSION")]) {
       try {
         if (f)
-          return readFileSync31(f, "utf8").trim() || "unknown";
+          return readFileSync40(f, "utf8").trim() || "unknown";
       } catch {}
     }
     return "unknown";
@@ -20598,13 +22329,13 @@ function createApp(opts) {
     }
     if (!uiDir || p.startsWith("/v1/"))
       return c.json({ error: "not found" }, 404);
-    const root = resolve8(uiDir);
-    const f = resolve8(root, `.${p}`);
-    if (f.startsWith(root + sep14) && existsSync24(f) && statSync15(f).isFile())
+    const root = resolve12(uiDir);
+    const f = resolve12(root, `.${p}`);
+    if (f.startsWith(root + sep14) && existsSync33(f) && statSync17(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(join40(root, "index.html")));
+    return new Response(Bun.file(join53(root, "index.html")));
   });
   return { app, db, close: () => {
     clearInterval(reconciler);