loki-mode 10.10.1 → 10.10.2

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

@@ -6959,8 +6959,8 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // src/server/app.ts
-import { existsSync as existsSync19, statSync as statSync13 } from "fs";
-import { join as join31, resolve as resolve6, sep as sep11 } from "path";
+import { existsSync as existsSync21, statSync as statSync14 } from "fs";
+import { join as join33, resolve as resolve6, sep as sep12 } from "path";
 
 // node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = Symbol();
@@ -16448,13 +16448,13 @@ data: ${JSON.stringify({ source: k.slice(0, i), run: k.slice(i + 1) })}
 }
 
 // src/server/routes/verify.ts
-import { readFileSync as readFileSync25, realpathSync as realpathSync12 } from "fs";
+import { readFileSync as readFileSync26, realpathSync as realpathSync13 } from "fs";
 import { createPublicKey as createPublicKey5 } from "crypto";
-import { join as join29, sep as sep10 } from "path";
+import { join as join31, sep as sep11 } from "path";
 
 // ../../loki-ts/src/engine10/verify_cmd.ts
-import { existsSync as existsSync17, readdirSync as readdirSync12, readFileSync as readFileSync24, statSync as statSync12 } from "fs";
-import { dirname as dirname12, join as join28 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync12, readFileSync as readFileSync25, statSync as statSync13 } from "fs";
+import { dirname as dirname12, join as join30 } from "path";
 import { createHash as createHash10, createPublicKey as createPublicKey4, verify as verify3 } from "crypto";
 
 // ../../loki-ts/src/util/paths.ts
@@ -16479,9 +16479,9 @@ var REPO_ROOT = findRepoRoot();
 
 // ../../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 chmodSync4, existsSync as existsSync16, readdirSync as readdirSync11, linkSync, mkdirSync as mkdirSync8, readFileSync as readFileSync22, statSync as statSync11, unlinkSync as unlinkSync4, writeFileSync as writeFileSync9 } from "fs";
+import { chmodSync as chmodSync4, existsSync as existsSync18, readdirSync as readdirSync11, linkSync, mkdirSync as mkdirSync9, readFileSync as readFileSync23, statSync as statSync12, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename9, dirname as dirname11, join as join27 } from "path";
+import { basename as basename9, dirname as dirname11, join as join29 } from "path";
 
 // ../../loki-ts/src/e10ext/assert_delta.ts
 import { execFileSync as execFileSync3 } from "child_process";
@@ -17004,10 +17004,257 @@ async function run(argv, opts = {}) {
 
 // ../../loki-ts/src/features/visual_evidence.ts
 import { spawn as spawn5 } from "child_process";
+
+// ../../loki-ts/src/project_model/discover.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync19, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
+import { join as join25 } 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 },
+  seal: { targetS: 15, limitS: 60 },
+  pr: { targetS: 15, limitS: 60 },
+  deep: { targetS: null, limitS: 2700 }
+};
+
+// ../../loki-ts/src/project_model/schema.ts
+import { existsSync as existsSync13, lstatSync as lstatSync5, realpathSync as realpathSync12, statSync as statSync10 } from "fs";
+import { isAbsolute, join as join24, 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(sep9).join("/").replace(/\/$/, "");
+  if (n2 === "" || isAbsolute(n2) || n2 === ".." || n2.startsWith("../"))
+    return null;
+  return n2;
+}
+function insideRepo(repoDir, rel) {
+  try {
+    const real2 = realpathSync12(join24(repoDir, rel));
+    const base = realpathSync12(repoDir);
+    return real2 === base || real2.startsWith(base + sep9);
+  } catch {
+    return false;
+  }
+}
+function checkCitation(repoDir, raw2) {
+  if (!isStr(raw2))
+    return "citation is not a non-empty string";
+  const rel = safeRel(raw2.replace(/:\d+(?:-\d+)?$/, ""));
+  if (rel === null)
+    return `citation "${raw2}" is not a repo-relative path`;
+  const abs = join24(repoDir, rel);
+  if (!existsSync13(abs) || !statSync10(abs).isFile() || !insideRepo(repoDir, rel))
+    return `citation "${raw2}" names a file that does not exist`;
+  return null;
+}
+function checkFingerprint(repoDir, raw2) {
+  if (!isStr(raw2))
+    return "fingerprint entry is not a non-empty string";
+  const rel = safeRel(raw2.replace(/:\d+(?:-\d+)?$/, ""));
+  if (rel === null)
+    return `fingerprint "${raw2}" is not a repo-relative path`;
+  try {
+    if (!lstatSync5(join24(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`;
+  }
+  return null;
+}
+function checkCites(repoDir, v, where, errs) {
+  if (!Array.isArray(v) || v.length === 0) {
+    errs.push(`${where}: needs at least one citation (a repo-relative file path)`);
+    return [];
+  }
+  const out2 = [];
+  for (const c of v) {
+    const e = checkCitation(repoDir, c);
+    if (e)
+      errs.push(`${where}: ${e}`);
+    else
+      out2.push(String(c));
+  }
+  return out2;
+}
+function checkDir(repoDir, v, where, errs) {
+  const rel = isStr(v) ? safeRel(v) : null;
+  if (rel === null) {
+    errs.push(`${where}: must be a repo-relative directory ("." for the repo root)`);
+    return ".";
+  }
+  const abs = join24(repoDir, rel);
+  if (!existsSync13(abs) || !statSync10(abs).isDirectory() || !insideRepo(repoDir, rel))
+    errs.push(`${where}: directory "${rel}" does not exist`);
+  return rel;
+}
+function checkCommand(repoDir, v, where, errs) {
+  if (v === null || v === undefined)
+    return null;
+  if (!isRec(v) || !isStr(v.cmd)) {
+    errs.push(`${where}: must be null or {cmd, cwd, cite}`);
+    return null;
+  }
+  const cwd = checkDir(repoDir, v.cwd, `${where}.cwd`, errs);
+  return { cmd: v.cmd.trim(), cwd, cite: checkCites(repoDir, v.cite, `${where}.cite`, errs) };
+}
+function validateAnswer(repoDir, raw2) {
+  const errs = [];
+  if (!isRec(raw2))
+    return { ok: false, errors: ["answer must be a JSON object"] };
+  if (!isStr(raw2.workspaceKind))
+    errs.push("workspaceKind: required non-empty string");
+  const workspaceCite = checkCites(repoDir, raw2.workspaceCite, "workspaceCite", errs);
+  if (!Array.isArray(raw2.packages))
+    errs.push("packages: required array");
+  const packages = [];
+  for (const [i, p] of (Array.isArray(raw2.packages) ? raw2.packages : []).entries()) {
+    const w = `packages[${i}]`;
+    if (!isRec(p) || !isStr(p.name)) {
+      errs.push(`${w}: must be an object with a name`);
+      continue;
+    }
+    const root = checkDir(repoDir, p.root, `${w}.root`, errs);
+    const cmds = isRec(p.commands) ? p.commands : {};
+    if (!isRec(p.commands))
+      errs.push(`${w}.commands: required object with keys ${COMMAND_KINDS.join(", ")} (each null or a command)`);
+    const commands = {};
+    for (const k of COMMAND_KINDS)
+      commands[k] = checkCommand(repoDir, cmds[k], `${w}.commands.${k}`, errs);
+    const ui = isRec(p.ui) ? p.ui : {};
+    if (!isRec(p.ui) || typeof ui.present !== "boolean")
+      errs.push(`${w}.ui: required {present: boolean, boot: command|null, cite}`);
+    packages.push({
+      name: p.name.trim(),
+      root,
+      runner: isStr(p.runner) ? p.runner.trim() : null,
+      commands,
+      ui: { present: ui.present === true, boot: checkCommand(repoDir, ui.boot, `${w}.ui.boot`, errs), cite: checkCites(repoDir, ui.cite, `${w}.ui.cite`, errs) },
+      cite: checkCites(repoDir, p.cite, `${w}.cite`, errs)
+    });
+  }
+  if (!Array.isArray(raw2.fingerprintFiles))
+    errs.push("fingerprintFiles: required array of the manifest and lockfile paths");
+  const fingerprintFiles = (Array.isArray(raw2.fingerprintFiles) ? raw2.fingerprintFiles : []).filter((f) => {
+    const e = checkFingerprint(repoDir, f);
+    if (e)
+      errs.push(`fingerprintFiles: ${e}`);
+    return e === null;
+  }).map((f) => String(f).replace(/:\d+(?:-\d+)?$/, ""));
+  if (errs.length > 0)
+    return { ok: false, errors: errs };
+  return { ok: true, model: { schema: PROJECT_MODEL_SCHEMA, status: "ok", workspaceKind: String(raw2.workspaceKind).trim(), workspaceCite, packages, fingerprintFiles } };
+}
+function unknownModel(key, reason, expiresAt) {
+  return { schema: PROJECT_MODEL_SCHEMA, status: "unknown", key, workspaceKind: "unknown", workspaceCite: [], packages: [], fingerprintFiles: [], reason, ...expiresAt === undefined ? {} : { expiresAt } };
+}
+function parseCached(repoDir, raw2, now) {
+  if (!isRec(raw2) || raw2.schema !== PROJECT_MODEL_SCHEMA || typeof raw2.key !== "string")
+    return null;
+  if (raw2.status === "unknown")
+    return typeof raw2.expiresAt === "number" && raw2.expiresAt > now ? unknownModel(raw2.key, typeof raw2.reason === "string" ? raw2.reason : "cached unknown", raw2.expiresAt) : null;
+  if (raw2.status !== "ok")
+    return null;
+  const v = validateAnswer(repoDir, raw2);
+  return v.ok ? { ...v.model, key: raw2.key } : null;
+}
+
+// ../../loki-ts/src/project_model/gather.ts
+var GATHER_CAPS = {
+  maxListFiles: 20000,
+  maxDepth: 3,
+  maxFileBytes: 16 * 1024,
+  maxFiles: 60,
+  maxTotalBytes: 96 * 1024,
+  maxTreeLines: 300,
+  maxHashBytes: 16 * 1024 * 1024
+};
+
+// ../../loki-ts/src/project_model/discover.ts
+function projectModelEnabled(env = process.env) {
+  return env["LOKI_E10_PROJECT_MODEL"] !== "0";
+}
+var PROJECT_FILE = ".loki/project.json";
+var UNKNOWN_TTL_MS = 60 * 60 * 1000;
+function loadCached(repoDir, now = Date.now()) {
+  try {
+    return parseCached(repoDir, JSON.parse(readFileSync19(join25(repoDir, PROJECT_FILE), "utf8")), now);
+  } catch {
+    return null;
+  }
+}
+
+// ../../loki-ts/src/project_model/api.ts
+import { posix } from "path";
+var clean = (p) => typeof p === "string" ? posix.normalize(p.replace(/\\/g, "/")).replace(/^\.\//, "") : "";
+var isRec2 = (v) => typeof v === "object" && v !== null;
+var wellFormed = (p) => isRec2(p) && typeof p.root === "string" && typeof p.name === "string";
+function projectApi(model) {
+  const known = isRec2(model) && model.status === "ok";
+  const packages = known && Array.isArray(model.packages) ? model.packages.filter(wellFormed) : [];
+  const packageOf = (file) => {
+    const f = clean(file);
+    if (f === "")
+      return null;
+    let best = null;
+    for (const p of packages) {
+      const hit = p.root === "." || f === p.root || f.startsWith(`${p.root}/`);
+      if (hit && (best === null || p.root !== "." && (best.root === "." || p.root.length > best.root.length)))
+        best = p;
+    }
+    return best;
+  };
+  return {
+    model,
+    known: () => known,
+    packages: () => packages,
+    workspaceKind: () => isRec2(model) && typeof model.workspaceKind === "string" ? model.workspaceKind : "unknown",
+    packageRootOf: (file) => packageOf(file)?.root ?? null,
+    packageOf,
+    relativeToRoot: (file) => {
+      const p = packageOf(file);
+      return p ? p.root === "." ? clean(file) : clean(file).slice(p.root.length + 1) : null;
+    },
+    commandFor: (pkg, kind) => (packages.find((p) => p.root === clean(pkg) || p.name === pkg) ?? null)?.commands?.[kind] ?? null,
+    hasUI: () => packages.some((p) => isRec2(p.ui) && p.ui.present === true),
+    uiBoot: () => {
+      for (const p of packages)
+        if (isRec2(p.ui) && p.ui.present === true && isRec2(p.ui.boot))
+          return { pkg: p, boot: p.ui.boot };
+      return null;
+    }
+  };
+}
+
+// ../../loki-ts/src/project_model/resolve.ts
+function loadProjectApi(repoDir, env = process.env) {
+  if (!projectModelEnabled(env))
+    return null;
+  try {
+    const model = loadCached(repoDir);
+    const api = model ? projectApi(model) : null;
+    return api && api.known() ? api : null;
+  } catch {
+    return null;
+  }
+}
+function isMultiRoot(api) {
+  return !!api && api.known() && api.packages().some((p) => p.root !== ".");
+}
+
+// ../../loki-ts/src/features/visual_evidence.ts
 import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync13, lstatSync as lstatSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync15, lstatSync as lstatSync6, mkdirSync as mkdirSync7, readdirSync as readdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync8 } from "fs";
 import { createServer } from "net";
-import { dirname as dirname8, isAbsolute, join as join24, normalize, relative as relative3, sep as sep9 } from "path";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join26, normalize as normalize2, relative as relative3, sep as sep10 } 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);
@@ -17017,12 +17264,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(readFileSync19(p)).digest("hex");
+var sha256File = (p) => createHash6("sha256").update(readFileSync20(p)).digest("hex");
 function hashScreens(runDir, rels) {
   const out2 = [];
   for (const rel of rels) {
     try {
-      out2.push({ path: rel, sha256: sha256File(join24(runDir, rel)) });
+      out2.push({ path: rel, sha256: sha256File(join26(runDir, rel)) });
     } catch {}
   }
   return out2;
@@ -17033,16 +17280,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 (isAbsolute(s.path) || normalize(s.path).startsWith(".."))
+    if (isAbsolute2(s.path) || normalize2(s.path).startsWith(".."))
       return `evidence screenshot path escapes the evidence dir: ${s.path}`;
-    const file = join24(runDir, s.path);
+    const file = join26(runDir, s.path);
     let cur = runDir;
-    for (const seg of normalize(s.path).split(sep9)) {
-      cur = join24(cur, seg);
+    for (const seg of normalize2(s.path).split(sep10)) {
+      cur = join26(cur, seg);
       if (isSymlink(cur))
         return `evidence screenshot path is a symlink: ${s.path}`;
     }
-    if (!existsSync13(file))
+    if (!existsSync15(file))
       return `evidence screenshot is missing: ${s.path}`;
     if (!isRegularFile(file))
       return `evidence screenshot is not a regular file: ${s.path}`;
@@ -17084,16 +17331,16 @@ async function waitUp(url, ms, signal) {
   return false;
 }
 var playwrightBin = (repoDir) => {
-  const bin = join24(repoDir, "node_modules", ".bin", "playwright");
-  return existsSync13(bin) ? bin : null;
+  const bin = join26(repoDir, "node_modules", ".bin", "playwright");
+  return existsSync15(bin) ? bin : null;
 };
 function openapiPaths(repoDir) {
   for (const f of ["openapi.json", "openapi.yaml", "openapi.yml", "swagger.json"]) {
-    const p = join24(repoDir, f);
-    if (!existsSync13(p))
+    const p = join26(repoDir, f);
+    if (!existsSync15(p))
       continue;
     try {
-      const txt = readFileSync19(p, "utf8");
+      const txt = readFileSync20(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 {
@@ -17103,8 +17350,8 @@ function openapiPaths(repoDir) {
   return [];
 }
 var playwrightTestPkg = (repoDir) => {
-  const d = join24(repoDir, "node_modules", "@playwright", "test");
-  return existsSync13(join24(d, "package.json")) ? d : null;
+  const d = join26(repoDir, "node_modules", "@playwright", "test");
+  return existsSync15(join26(d, "package.json")) ? d : null;
 };
 var e2eSpecSource = (pkgDir, base, routes) => `const { test } = require(${JSON.stringify(pkgDir)});
 test("loki e2e walkthrough", async ({ page }) => {
@@ -17116,24 +17363,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 = join24(runDir, relDir, "e2e");
-    mkdirSync6(dir, { recursive: true });
-    writeFileSync7(join24(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
-    writeFileSync7(join24(dir, "playwright.config.cjs"), `module.exports = { testDir: ".", testMatch: "walk.spec.cjs", outputDir: "./out", reporter: "null", use: { video: "on", trace: "on" } };
+    const dir = join26(runDir, relDir, "e2e");
+    mkdirSync7(dir, { recursive: true });
+    writeFileSync8(join26(dir, "walk.spec.cjs"), e2eSpecSource(pkg, base, routes));
+    writeFileSync8(join26(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", join24(dir, "playwright.config.cjs")], repoDir, ms, signal))
+    if (!await shoot(pw, ["test", "--config", join26(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 = join24(d, e.name);
+        const full = join26(d, e.name);
         if (e.isDirectory())
           walk(full);
         else if (e.isFile() && /\.(webm|zip)$/.test(e.name))
-          rels.push(join24(relDir, "e2e", relative3(dir, full)));
+          rels.push(join26(relDir, "e2e", relative3(dir, full)));
       }
     };
-    walk(join24(dir, "out"));
+    walk(join26(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)}` };
@@ -17171,14 +17418,14 @@ function shoot(pw, args, cwd, ms, signal) {
 }
 var isSymlink = (p) => {
   try {
-    return lstatSync5(p).isSymbolicLink();
+    return lstatSync6(p).isSymbolicLink();
   } catch {
     return false;
   }
 };
 var isRegularFile = (p) => {
   try {
-    return lstatSync5(p).isFile();
+    return lstatSync6(p).isFile();
   } catch {
     return false;
   }
@@ -17226,24 +17473,30 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
   try {
     if (!visualEvidenceEnabled(opts.env))
       return skip("LOKI_VISUAL_EVIDENCE is 0");
-    const pkgPath = join24(repoDir, "package.json");
-    if (!existsSync13(pkgPath))
-      return skip("no package.json");
-    const script = pickScript(JSON.parse(readFileSync19(pkgPath, "utf8")));
-    if (!script)
-      return skip("no dev, preview or start script");
+    const api = loadProjectApi(repoDir), boot = isMultiRoot(api) ? api.uiBoot() : null;
+    const appDir = boot ? join26(repoDir, boot.boot.cwd) : repoDir;
+    const pkgPath = join26(appDir, "package.json");
+    let script = null;
+    if (!boot) {
+      if (!existsSync15(pkgPath))
+        return skip("no package.json");
+      script = pickScript(JSON.parse(readFileSync20(pkgPath, "utf8")));
+      if (!script)
+        return skip("no dev, preview or start script");
+    }
     const pages = changed.filter(isPageFile);
     const explicitOn = (opts.env ?? process.env)["LOKI_VISUAL_EVIDENCE"] === "1";
     const apiPaths = pages.length === 0 && explicitOn ? openapiPaths(repoDir) : [];
     if (pages.length === 0 && apiPaths.length === 0)
       return skip(explicitOn ? "no changed page files and no openapi routes" : "no changed page files (set LOKI_VISUAL_EVIDENCE=1 for the API transcript)");
-    const pw = pages.length > 0 ? playwrightBin(repoDir) : null;
+    const pw = pages.length > 0 ? playwrightBin(appDir) ?? playwrightBin(repoDir) : null;
     if (pages.length > 0 && !pw)
       return skip("playwright not resolvable in the repo");
     const budget = opts.budgetMs ?? DEFAULT_BUDGET_MS, end = Date.now() + budget, left = () => end - Date.now();
     const aborted = () => signal?.aborted === true;
     const port = await freePort(), base = `http://127.0.0.1:${port}`;
-    child = spawn5("npm", ["run", script, "--silent"], { cwd: repoDir, detached: true, env: { ...opts.env ?? process.env, PORT: String(port), HOST: "127.0.0.1", BROWSER: "none" }, stdio: "ignore" });
+    const [bc, ba] = boot ? ["bash", ["-c", boot.boot.cmd]] : ["npm", ["run", script, "--silent"]];
+    child = spawn5(bc, [...ba], { cwd: appDir, detached: true, env: { ...opts.env ?? process.env, PORT: String(port), HOST: "127.0.0.1", BROWSER: "none" }, stdio: "ignore" });
     child.on("error", () => {
       return;
     });
@@ -17254,26 +17507,26 @@ 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 = join24(runDir, "evidence");
+    const evRoot = join26(runDir, "evidence");
     if (isSymlink(evRoot))
       return skip("evidence dir is a symlink");
-    mkdirSync6(evRoot, { recursive: true });
+    mkdirSync7(evRoot, { recursive: true });
     if (pages.length > 0) {
-      const rel0 = join24("evidence", randomBytes2(6).toString("hex"));
-      mkdirSync6(join24(runDir, rel0));
+      const rel0 = join26("evidence", randomBytes2(6).toString("hex"));
+      mkdirSync7(join26(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 = join24(rel0, `${screenName(route)}.png`);
-        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join24(runDir, rel)], repoDir, left(), signal);
-        if (ok && !aborted() && !isSymlink(join24(runDir, rel)) && existsSync13(join24(runDir, rel)))
+        const rel = join26(rel0, `${screenName(route)}.png`);
+        const ok = await shoot(pw, ["screenshot", `${base}${route}`, join26(runDir, rel)], appDir, left(), signal);
+        if (ok && !aborted() && !isSymlink(join26(runDir, rel)) && existsSync15(join26(runDir, rel)))
           rels.push(rel);
       }
       if (aborted())
         return skip("aborted");
       const routes = [...new Set(pages.map(routeFor))].slice(0, opts.maxRoutes ?? MAX_ROUTES);
-      const media = rels.length > 0 && left() > 0 ? await recordE2eMedia(repoDir, runDir, rel0, base, routes, left(), signal) : { rels: [], skipped: null };
+      const media = rels.length > 0 && left() > 0 ? await recordE2eMedia(appDir, runDir, rel0, base, routes, left(), signal) : { rels: [], skipped: null };
       if (aborted())
         return skip("aborted");
       const screens = hashScreens(runDir, [...rels, ...media.rels]);
@@ -17292,9 +17545,9 @@ async function captureVisualEvidence(repoDir, runDir, changed, opts = {}) {
     }
     if (aborted())
       return skip("aborted");
-    const hdir = join24(evRoot, randomBytes2(6).toString("hex"));
-    mkdirSync6(hdir);
-    writeFileSync7(join24(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
+    const hdir = join26(evRoot, randomBytes2(6).toString("hex"));
+    mkdirSync7(hdir);
+    writeFileSync8(join26(hdir, "http.json"), JSON.stringify(rows, null, 2) + `
 `);
     return { screens: [], http: true, skipped: null };
   } catch (e) {
@@ -17320,23 +17573,9 @@ function receiptScreensProblem(receiptPath, receipt) {
   return receipt["evidence_screens"] === undefined ? null : checkScreens(dirname8(receiptPath), receipt["evidence_screens"]);
 }
 
-// ../../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/features/contract.ts
-import { existsSync as existsSync14, lstatSync as lstatSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync20, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname9, join as join25 } from "path";
+import { existsSync as existsSync16, lstatSync as lstatSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname9, join as join27 } from "path";
 import { createHash as createHash7 } from "crypto";
 var MAX_CRITERIA = 50;
 var MAX_TEXT = 500;
@@ -17371,14 +17610,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 join25(repoDir, ".loki", "contract.json");
+  return join27(repoDir, ".loki", "contract.json");
 }
 var MAX_CONTRACT_BYTES = 1024 * 1024;
 function readContract(repoDir) {
   const p = contractPath(repoDir);
   let st;
   try {
-    st = lstatSync6(p);
+    st = lstatSync7(p);
   } catch {
     return { contract: null, notes: [], sha256: null };
   }
@@ -17388,7 +17627,7 @@ function readContract(repoDir) {
     return { contract: null, notes: ["contract unreadable: too large"], sha256: null };
   let raw2;
   try {
-    raw2 = readFileSync20(p);
+    raw2 = readFileSync21(p);
   } catch {
     return { contract: null, notes: ["contract unreadable: read failed"], sha256: null };
   }
@@ -17423,7 +17662,7 @@ function sealContract(repoDir, body, rawDiff, checks, env = process.env, snap) {
     const live = readContract(repoDir);
     let exists2 = true;
     try {
-      lstatSync6(contractPath(repoDir));
+      lstatSync7(contractPath(repoDir));
     } catch {
       exists2 = false;
     }
@@ -17452,18 +17691,18 @@ 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 existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync21, statSync as statSync10 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync22, statSync as statSync11 } from "fs";
+import { dirname as dirname10, join as join28 } 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 isObj9 = (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 num2 = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
-var unitsDir = (runDir) => join26(runDir, "group", "units");
+var unitsDir = (runDir) => join28(runDir, "group", "units");
 var readJson3 = (p) => {
   try {
-    return JSON.parse(readFileSync21(p, "utf8"));
+    return JSON.parse(readFileSync22(p, "utf8"));
   } catch {
     return;
   }
@@ -17476,8 +17715,8 @@ var dirNames = (d) => {
   }
 };
 function sealGroup(runDir, rh) {
-  const manifestPath = join26(runDir, "group", "manifest.json");
-  if (!existsSync15(manifestPath))
+  const manifestPath = join28(runDir, "group", "manifest.json");
+  if (!existsSync17(manifestPath))
     return { section: undefined, notProven: [], problems: 0, allUnitsPass: true };
   const notProven = [];
   let problems = 0;
@@ -17501,10 +17740,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 = join26(unitsDir(runDir), id), rp = join26(dir, "receipt.json"), ep = join26(dir, "events.jsonl");
+    const dir = join28(unitsDir(runDir), id), rp = join28(dir, "receipt.json"), ep = join28(dir, "events.jsonl");
     let bytes;
     try {
-      bytes = readFileSync21(rp);
+      bytes = readFileSync22(rp);
     } catch {
       return fail(`unit ${id} sub-receipt missing`);
     }
@@ -17521,7 +17760,7 @@ function sealGroup(runDir, rh) {
       unit_id: id,
       sub_receipt_sha256: sha2(bytes),
       receipt_sha256: sub["receipt_sha256"],
-      events_file_sha256: existsSync15(ep) ? sha2(readFileSync21(ep)) : null,
+      events_file_sha256: existsSync17(ep) ? sha2(readFileSync22(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),
@@ -17546,7 +17785,7 @@ async function verifyGroup(receiptPath, receipt, rh, verifyOne, deps = {}) {
   const bad = (reason) => ({ verdict: "TAMPERED", reason: `group: ${reason}` });
   const g = receipt["group"];
   if (g === undefined)
-    return existsSync15(join26(runDir, "group", "manifest.json")) ? bad("group directory present but the receipt has no group section") : null;
+    return existsSync17(join28(runDir, "group", "manifest.json")) ? bad("group directory present but the receipt has no group section") : null;
   if (!isObj9(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"];
@@ -17558,20 +17797,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 = join26(unitsDir(runDir), id), rp = join26(dir, "receipt.json"), ep = join26(dir, "events.jsonl");
+    const e = entries[i], id = ids[i], dir = join28(unitsDir(runDir), id), rp = join28(dir, "receipt.json"), ep = join28(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 (!statSync10(dir).isDirectory())
+      if (!statSync11(dir).isDirectory())
         return bad(`unit ${id} is not a directory`);
-      bytes = readFileSync21(rp);
+      bytes = readFileSync22(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 = existsSync15(ep) ? sha2(readFileSync21(ep)) : null;
+    const evSha = existsSync17(ep) ? sha2(readFileSync22(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);
@@ -17626,21 +17865,21 @@ function loadSigningKey(generate = true) {
     let pem = inline ?? "";
     if (!inline) {
       const given = process.env["LOKI_RECEIPT_SIGNING_KEY_FILE"]?.trim();
-      const file = given || join27(process.env["HOME"] || homedir6(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
+      const file = given || join29(process.env["HOME"] || homedir6(), ".loki", "keys", RECEIPT_SIGNER_BASENAME);
       try {
-        pem = readFileSync22(file);
+        pem = readFileSync23(file);
         if (!given) {
           for (const [f, m] of [[file, 384], [dirname11(file), 448]])
-            if (statSync11(f).mode & 63)
+            if (statSync12(f).mode & 63)
               chmodSync4(f, m);
         }
       } catch (e) {
         if (e.code !== "ENOENT" || !generate)
           return null;
-        mkdirSync8(dirname11(dirname11(file)), { recursive: true, mode: 448 });
-        mkdirSync8(dirname11(file), { recursive: true, mode: 448 });
+        mkdirSync9(dirname11(dirname11(file)), { recursive: true, mode: 448 });
+        mkdirSync9(dirname11(file), { recursive: true, mode: 448 });
         const tmp = `${file}.${randomBytes3(6).toString("hex")}.tmp`;
-        writeFileSync9(tmp, generateKeyPairSync("ed25519").privateKey.export({ type: "pkcs8", format: "pem" }), { flag: "wx", mode: 384 });
+        writeFileSync10(tmp, generateKeyPairSync("ed25519").privateKey.export({ type: "pkcs8", format: "pem" }), { flag: "wx", mode: 384 });
         try {
           linkSync(tmp, file);
         } catch (l) {
@@ -17649,7 +17888,7 @@ function loadSigningKey(generate = true) {
         } finally {
           unlinkSync4(tmp);
         }
-        pem = readFileSync22(file);
+        pem = readFileSync23(file);
       }
     }
     const k = createPrivateKey(pem);
@@ -17776,7 +18015,7 @@ var sealStage = {
     if (wallNotRun > 0) {
       try {
         const kept = new Set((Array.isArray(o.wall?.files) ? o.wall.files : []).map((f) => basename9(String(f.path))));
-        for (const n2 of readdirSync11(join27(ctx.runDir, "wall")).sort())
+        for (const n2 of readdirSync11(join29(ctx.runDir, "wall")).sort())
           if (!kept.has(n2))
             notProven.add(`wall test discarded: ${n2} (not_run)`);
       } catch {}
@@ -17836,7 +18075,7 @@ var sealStage = {
     const cost = ctx.cost.read(ctx.repoDir, iterIds);
     if (cost.unmetered)
       notProven.add("cost unmetered (CLI invoker; recorded as 0)");
-    const eventsPath = join27(ctx.runDir, "events.jsonl");
+    const eventsPath = join29(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)
@@ -17872,7 +18111,7 @@ var sealStage = {
       provider: ctx.provider,
       model: ctx.model,
       resumed: o.intake?.resumed === true,
-      events_sha256: sha2562(existsSync16(eventsPath) ? readFileSync22(eventsPath) : ""),
+      events_sha256: sha2562(existsSync18(eventsPath) ? readFileSync23(eventsPath) : ""),
       ...await sealEvidence(ctx.repoDir, ctx.runDir, o, notProven, signal, ctx.emit),
       log_seal: true
     };
@@ -17886,11 +18125,11 @@ var sealStage = {
       hash = receiptSha256(body);
     }
     const receipt = { ...body, receipt_sha256: hash, verification: { jwt: sig.jwt, kid: sig.kid } };
-    mkdirSync8(ctx.runDir, { recursive: true });
-    const path = join27(ctx.runDir, "receipt.json");
-    writeFileSync9(path, JSON.stringify(receipt, null, 2) + `
+    mkdirSync9(ctx.runDir, { recursive: true });
+    const path = join29(ctx.runDir, "receipt.json");
+    writeFileSync10(path, JSON.stringify(receipt, null, 2) + `
 `);
-    writeFileSync9(join27(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
+    writeFileSync10(join29(ctx.runDir, "receipt.md"), renderReceiptMd(receipt));
     const signed = sig.jwt !== null;
     const data = { receipt_path: path, receipt_sha256: hash, signed, kid: sig.kid, verdict, not_proven: receipt.not_proven };
     ctx.emit("receipt.sealed", "seal", { path, receipt_sha256: hash, signed, kid: sig.kid, verdict, not_proven: receipt.not_proven });
@@ -17900,7 +18139,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 readFileSync23 } from "fs";
+import { readFileSync as readFileSync24 } 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";
@@ -17981,7 +18220,7 @@ function verifyDsseReceipt(env, d) {
 }
 function runIdGuard(receiptPath, runId) {
   try {
-    return envelopeRunIdProblem(JSON.parse(readFileSync23(receiptPath, "utf8")), runId);
+    return envelopeRunIdProblem(JSON.parse(readFileSync24(receiptPath, "utf8")), runId);
   } catch {
     return null;
   }
@@ -17995,7 +18234,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(readFileSync24(f))];
+      return [createPublicKey4(readFileSync25(f))];
     } catch {
       return [];
     }
@@ -18027,10 +18266,10 @@ function checkEventLog(receiptPath, receipt) {
   const bound = receipt["events_sha256"];
   if (typeof bound !== "string" || bound === createHash10("sha256").digest("hex"))
     return null;
-  const path = join28(dirname12(receiptPath), "events.jsonl");
-  if (!existsSync17(path))
+  const path = join30(dirname12(receiptPath), "events.jsonl");
+  if (!existsSync19(path))
     return "events.jsonl is missing";
-  const raw2 = readFileSync24(path, "utf8"), events2 = readEvents(path), lines = raw2.split(`
+  const raw2 = readFileSync25(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";
@@ -18046,7 +18285,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 = join28(dirname12(receiptPath), "events.jsonl"), events2 = readEvents(path), done = events2.findIndex((e) => e.type === "run.completed");
+  const path = join30(dirname12(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)
@@ -18054,7 +18293,7 @@ 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 = readFileSync24(path, "utf8").split(`
+  const lines = readFileSync25(path, "utf8").split(`
 `).filter((l) => l.trim() !== ""), sha3 = createHash10("sha256").update(lines.slice(0, done + 1).join(`
 `) + `
 `).digest("hex");
@@ -18064,11 +18303,11 @@ function checkLogSeal(receiptPath, hash, kid, given) {
   return null;
 }
 async function verifyReceipt(receiptPath, deps = {}) {
-  if (!existsSync17(receiptPath))
+  if (!existsSync19(receiptPath))
     return { verdict: "UNCHECKED", reasons: [`receipt not found: ${receiptPath}`] };
   let receipt;
   try {
-    receipt = JSON.parse((deps.read ?? ((p) => readFileSync24(p, "utf8")))(receiptPath));
+    receipt = JSON.parse((deps.read ?? ((p) => readFileSync25(p, "utf8")))(receiptPath));
   } catch {
     return { verdict: "UNCHECKED", reasons: ["receipt.json is not valid JSON"] };
   }
@@ -18136,15 +18375,15 @@ function mount19(ctx) {
       return done(404, "receipt not available", "not_found");
     let runDir, file;
     try {
-      const root = realpathSync12(join29(repo.p, ".loki", "runs"));
-      runDir = realpathSync12(join29(root, run2));
-      if (runDir !== join29(root, run2))
+      const root = realpathSync13(join31(repo.p, ".loki", "runs"));
+      runDir = realpathSync13(join31(root, run2));
+      if (runDir !== join31(root, run2))
         return done(404, "receipt not found", "not_found");
-      file = realpathSync12(join29(runDir, "receipt.json"));
+      file = realpathSync13(join31(runDir, "receipt.json"));
     } catch {
       return done(404, "receipt not found", "not_found");
     }
-    if (!file.startsWith(runDir + sep10))
+    if (!file.startsWith(runDir + sep11))
       return done(404, "receipt not found", "not_found");
     let integrity, reasons, sha3 = null, outcome = "UNREADABLE";
     try {
@@ -18159,7 +18398,7 @@ function mount19(ctx) {
         sha3 = r.receiptSha256 ?? null;
       }
       try {
-        outcome = outcomeOf(JSON.parse(readFileSync25(file, "utf8")));
+        outcome = outcomeOf(JSON.parse(readFileSync26(file, "utf8")));
       } catch {
         outcome = "UNREADABLE";
       }
@@ -18221,8 +18460,8 @@ function ttlCache(ttlMs = PROBE_CACHE_MS, now = Date.now) {
 }
 
 // src/server/legacy/shim.ts
-import { existsSync as existsSync18, readFileSync as readFileSync26 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync27 } from "fs";
+import { join as join32 } from "path";
 
 // src/server/legacy/routes.ts
 var LEGACY_ROUTES = [
@@ -18594,10 +18833,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 [join30(import.meta.dir, "../../../../../VERSION")]) {
+  for (const f of [join32(import.meta.dir, "../../../../../VERSION")]) {
     try {
-      if (existsSync18(f))
-        return readFileSync26(f, "utf8").trim();
+      if (existsSync20(f))
+        return readFileSync27(f, "utf8").trim();
     } catch {}
   }
   return "unknown";
@@ -18779,7 +19018,7 @@ function legacyShim(opts) {
 
 // src/server/app.ts
 var MAX_BODY2 = 1e6;
-var defaultUiDir = () => [join31(import.meta.dir, "../../ui/dist"), join31(import.meta.dir, "../ui/dist")].find((d) => existsSync19(join31(d, "index.html")));
+var defaultUiDir = () => [join33(import.meta.dir, "../../ui/dist"), join33(import.meta.dir, "../ui/dist")].find((d) => existsSync21(join33(d, "index.html")));
 function createApp(opts) {
   const uiDir = opts.uiDir ?? defaultUiDir();
   const { db, sqlite } = openDb(opts.dbPath);
@@ -18905,11 +19144,11 @@ function createApp(opts) {
       return c.json({ error: "not found" }, 404);
     const root = resolve6(uiDir);
     const f = resolve6(root, `.${p}`);
-    if (f.startsWith(root + sep11) && existsSync19(f) && statSync13(f).isFile())
+    if (f.startsWith(root + sep12) && existsSync21(f) && statSync14(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(join31(root, "index.html")));
+    return new Response(Bun.file(join33(root, "index.html")));
   });
   return { app, db, close: () => sqlite.close() };
 }