loki-mode 10.6.14 → 10.7.1

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

@@ -15,8 +15,8 @@ var __export = (target, all) => {
 };
 
 // src/server/app.ts
-import { existsSync as existsSync2, statSync } from "fs";
-import { join as join3, resolve, sep } from "path";
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { join as join6, resolve as resolve2, sep } from "path";
 
 // node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = Symbol();
@@ -5490,7 +5490,8 @@ var exports_schema = {};
 __export(exports_schema, {
   sources: () => sources,
   runs: () => runs,
-  events: () => events
+  events: () => events,
+  audit: () => audit
 });
 var sources = sqliteTable("sources", {
   id: text("id").primaryKey(),
@@ -5537,20 +5538,35 @@ var runs = sqliteTable("runs", {
   tampered: integer("tampered").notNull(),
   conflict: integer("conflict").notNull().default(0),
   groupId: text("group_id"),
-  unitId: text("unit_id")
+  unitId: text("unit_id"),
+  attested: integer("attested"),
+  sigChecked: integer("sig_checked"),
+  integrityKeyFp: text("integrity_key_fp"),
+  integrityReasons: text("integrity_reasons")
 }, (t) => [
   primaryKey({ columns: [t.sourceId, t.runId] }),
   index("runs_started").on(t.startedAt),
   index("runs_verdict").on(t.verdict),
   index("runs_group").on(t.groupId)
 ]);
+var audit = sqliteTable("audit", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  ts: text("ts").notNull(),
+  action: text("action").notNull(),
+  actor: text("actor").notNull(),
+  detail: text("detail", { mode: "json" }).notNull()
+});
 
 // src/db/migrate.ts
 function openDb(path) {
   const sqlite = new Database2(path, { create: true });
   sqlite.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
   const db = drizzle(sqlite, { schema: exports_schema });
-  const migrationsFolder = [join(import.meta.dir, "../../drizzle"), join(import.meta.dir, "../drizzle")].find((d) => existsSync(join(d, "meta/_journal.json")));
+  const migrationsFolder = [
+    join(import.meta.dir, "../../drizzle"),
+    join(import.meta.dir, "../drizzle"),
+    join(import.meta.dir, "../../packages/control-plane/drizzle")
+  ].find((d) => existsSync(join(d, "meta/_journal.json")));
   if (!migrationsFolder)
     throw new Error("drizzle migrations folder not found");
   migrate(db, { migrationsFolder });
@@ -5558,9 +5574,10 @@ function openDb(path) {
 }
 
 // src/server/ingest.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 
 // ../../loki-ts/src/engine10/events.ts
+import { closeSync, existsSync as existsSync2, fstatSync, mkdirSync, openSync, readFileSync, readSync, writeSync } from "fs";
 var isObj = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
 var ISO_TS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
 var KEYS = ["v", "seq", "ts", "run", "type", "stage", "data"];
@@ -5591,6 +5608,28 @@ function validateEnvelope(x) {
     return "deps must be a string array";
   return null;
 }
+function parseLine(line) {
+  if (line.trim() === "")
+    return null;
+  try {
+    const x = JSON.parse(line);
+    return validateEnvelope(x) === null ? x : null;
+  } catch {
+    return null;
+  }
+}
+function readEvents(path) {
+  if (!existsSync2(path))
+    return [];
+  const out = [];
+  for (const line of readFileSync(path, "utf8").split(`
+`)) {
+    const e = parseLine(line);
+    if (e)
+      out.push(e);
+  }
+  return out;
+}
 function fold(events2) {
   const f = {
     stages: {},
@@ -5667,7 +5706,7 @@ var RULES = [
 var redactSecrets = (s) => RULES.reduce((a, [re, to]) => a.replace(re, to), s);
 
 // src/server/answer.ts
-import { chmodSync, mkdirSync, writeFileSync } from "fs";
+import { chmodSync, mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 var MAX_ANSWER = 4000;
@@ -5687,7 +5726,7 @@ function writeAnswer(dir, source, run, answer) {
   if (answer.length > MAX_ANSWER)
     return { status: 413, body: { error: `answer over ${MAX_ANSWER} characters` } };
   const d = join2(dir, source);
-  mkdirSync(d, { recursive: true, mode: 448 });
+  mkdirSync2(d, { recursive: true, mode: 448 });
   const path = join2(d, `${run}.answer.txt`);
   writeFileSync(path, `${answer.trim()}
 `, { mode: 384 });
@@ -5695,6 +5734,149 @@ function writeAnswer(dir, source, run, answer) {
   return { status: 200, body: { ok: true, path, resume: `loki answer ${run}` } };
 }
 
+// src/server/integrity.ts
+import { createHash, createPublicKey, verify } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+var SHA = /^[0-9a-f]{64}$/;
+var SEAL_LINE = "log.sealed";
+var REDACTED = /\[REDACTED(?::[A-Z_]+)?\]/;
+var REDACTED_NOTE = "log redacted before ingest; seal not checkable";
+var UNATTESTED_SUFFIX = " (unattested)";
+var SUCCESS_VERDICTS = new Set(["VERIFIED", "ALREADY_SATISFIED"]);
+var normVerdict = (v) => typeof v === "string" ? v.trim().toUpperCase() : null;
+var kidOf = (pub) => createHash("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${pub.export({ format: "jwk" }).x}"}`).digest("base64url");
+function pubkeysFromEnv(env = process.env) {
+  const keys = (env["LOKI_CP_RECEIPT_PUBKEYS"] ?? "").split(":").map((f) => f.trim()).filter(Boolean).flatMap((f) => {
+    try {
+      return [createPublicKey(readFileSync2(f))];
+    } catch {
+      return [];
+    }
+  });
+  const fn = (kid) => keys.find((k) => kidOf(k) === kid);
+  fn.configured = keys.length > 0;
+  fn.fingerprint = createHash("sha256").update(keys.map(kidOf).sort().join(",")).digest("hex").slice(0, 16);
+  return fn;
+}
+var line = (e) => JSON.stringify({ v: e.v, seq: e.seq, ts: e.ts, run: e.run, type: e.type, stage: e.stage, data: e.data });
+var verdictOf = (e) => typeof e?.data["verdict"] === "string" ? e.data["verdict"].trim().toUpperCase() : null;
+function sealedPrefix(evs) {
+  const i = evs.findIndex((e) => e.type === SEAL_LINE);
+  return i < 0 ? [...evs] : evs.slice(0, i + 1);
+}
+function verifyRunIntegrity(evs, opts = {}) {
+  const bad = [], notes = [];
+  const doneAt = evs.findIndex((e) => e.type === "run.completed");
+  const sealedAt = evs.map((e, i) => e.type === "receipt.sealed" ? i : -1).filter((i) => i >= 0);
+  const finalised = doneAt >= 0 || sealedAt.length > 0;
+  const lines = evs.map(line);
+  const keysConfigured = opts.keysConfigured ?? opts.pubkeyFor?.configured ?? false;
+  let sigChecked = false;
+  if (finalised) {
+    const gap = evs.findIndex((e, i) => e.seq !== i);
+    if (gap >= 0)
+      bad.push(`event log has a seq gap, duplicate or missing start at position ${gap} (seq ${evs[gap].seq})`);
+  }
+  if (evs.some((e) => e.type === "tamper.detected"))
+    bad.push("the supervisor detected events.jsonl being modified during the run");
+  const firstSeal = evs.findIndex((e) => e.type === SEAL_LINE);
+  if (firstSeal >= 0 && evs.slice(firstSeal + 1).some((e) => e.type === "run.completed" || e.type === "receipt.sealed" || typeof e.data["verdict"] === "string"))
+    bad.push("a verdict-bearing event after log.sealed is unauthenticated");
+  if (evs.filter((e) => e.type === "run.completed").length > 1)
+    bad.push("more than one run.completed (a verdict appended after the seal is unauthenticated)");
+  const hashBad = [];
+  const redacted = REDACTED.test(JSON.stringify(doneAt >= 0 ? evs.slice(0, doneAt + 2).map((e) => e.data) : evs.map((e) => e.data)));
+  for (const i of sealedAt) {
+    const d = evs[i].data;
+    if (typeof d["receipt_sha256"] !== "string" || !SHA.test(d["receipt_sha256"]))
+      hashBad.push(`receipt.sealed at seq ${evs[i].seq} has no valid receipt_sha256`);
+    const bound = d["events_sha256"];
+    if (typeof bound === "string") {
+      const h = createHash("sha256");
+      let ok = false;
+      for (const l of lines) {
+        if (h.copy().digest("hex") === bound) {
+          ok = true;
+          break;
+        }
+        h.update(l + `
+`);
+      }
+      if (!ok && h.digest("hex") === bound)
+        ok = true;
+      if (!ok)
+        hashBad.push("receipt.sealed events_sha256 does not match any prefix of the ingested log");
+    }
+  }
+  const sealLines = evs.map((e, i) => e.type === SEAL_LINE ? i : -1).filter((i) => i >= 0);
+  if (sealLines.some((i) => i !== doneAt + 1))
+    bad.push(`${SEAL_LINE} is not the line right after run.completed`);
+  const ls = doneAt >= 0 && evs[doneAt + 1]?.type === SEAL_LINE ? evs[doneAt + 1].data : null;
+  const signedSeals = sealedAt.map((i) => evs[i].data).filter((d) => d["signed"] === true);
+  const signedReceipt = signedSeals.length > 0;
+  if (ls) {
+    const sha = createHash("sha256").update(lines.slice(0, doneAt + 1).join(`
+`) + `
+`).digest("hex");
+    const sig = typeof ls["sig"] === "string" ? Buffer.from(ls["sig"], "base64url") : null;
+    const kid = ls["kid"];
+    if (ls["tampered"] !== false)
+      bad.push(`${SEAL_LINE} line records a tamper or is malformed`);
+    else if (typeof kid !== "string" || !sig || sig.length !== 64)
+      hashBad.push(`${SEAL_LINE} line is malformed or records a tamper`);
+    else {
+      if (signedSeals.some((d) => typeof d["kid"] === "string" && d["kid"] !== kid))
+        hashBad.push(`${SEAL_LINE} kid differs from the receipt kid`);
+      if (ls["events_sha256"] !== sha)
+        hashBad.push(`${SEAL_LINE} events_sha256 does not match the ingested log`);
+      else {
+        const pub = opts.pubkeyFor?.(kid);
+        if (pub) {
+          sigChecked = true;
+          if (!verify(null, Buffer.from(`${sha}:false`), pub, sig))
+            bad.push(`${SEAL_LINE} signature does not verify`);
+        } else if (keysConfigured)
+          bad.push(`${SEAL_LINE} kid ${kid} has no configured public key`);
+      }
+    }
+  } else if (signedReceipt && doneAt >= 0)
+    bad.push(`signed receipt but no ${SEAL_LINE} line after run.completed`);
+  let unverifiable = false;
+  if (hashBad.length > 0) {
+    if (redacted) {
+      unverifiable = true;
+      sigChecked = false;
+      notes.push(REDACTED_NOTE);
+    } else
+      bad.push(...hashBad);
+  }
+  let claimsVerified = false;
+  const claimed = doneAt >= 0 ? verdictOf(evs[doneAt]) : null;
+  if (claimed !== null && SUCCESS_VERDICTS.has(claimed)) {
+    claimsVerified = true;
+    const before = sealedAt.filter((i) => i < doneAt);
+    if (before.length === 0)
+      bad.push(`run.completed claims ${claimed} but no receipt.sealed precedes it`);
+    else if (!before.some((i) => verdictOf(evs[i]) === claimed))
+      bad.push(`run.completed claims ${claimed} but the sealed receipt does not`);
+  }
+  const tampered = bad.length > 0;
+  const attested = !tampered && !unverifiable && (!claimsVerified || signedReceipt && ls !== null);
+  return { tampered, attested, sig_checked: sigChecked && !tampered, reasons: [...bad, ...notes] };
+}
+function effectiveVerdict(r) {
+  if (r.tampered)
+    return "TAMPERED";
+  const v = normVerdict(r.verdict);
+  if (v === null)
+    return r.verdict;
+  if (r.attested === false)
+    return SUCCESS_VERDICTS.has(v) ? "UNVERIFIED" : `${r.verdict}${UNATTESTED_SUFFIX}`;
+  if (SUCCESS_VERDICTS.has(v))
+    return r.sig_checked === false ? `${v} (signature not checked)` : v;
+  return r.verdict;
+}
+
 // src/server/runs.ts
 var str = (x) => typeof x === "string" ? x : null;
 function loadEvents(db, sourceId, runId) {
@@ -5704,8 +5886,11 @@ function rebuildRun(db, sourceId, runId) {
   const evs = loadEvents(db, sourceId, runId);
   if (evs.length === 0)
     return;
-  const f = fold(evs);
-  const pc = partialCost(evs, f.run.tampered);
+  const f = fold(sealedPrefix(evs));
+  const keys = pubkeysFromEnv();
+  const integ = verifyRunIntegrity(evs, { pubkeyFor: keys });
+  const tampered = f.run.tampered || integ.tampered;
+  const pc = partialCost(evs, tampered);
   const sd = f.run.started?.data ?? {};
   const done = f.run.completed?.data ?? {};
   const pr = evs.find((e) => e.type === "pr.opened")?.data;
@@ -5733,10 +5918,22 @@ function rebuildRun(db, sourceId, runId) {
     wallS: typeof done.wall_s === "number" ? done.wall_s : null,
     lastSeq: f.lastSeq,
     lastEventAt: evs[evs.length - 1]?.ts ?? null,
-    tampered: Number(f.run.tampered)
+    tampered: Number(tampered),
+    attested: Number(integ.attested),
+    sigChecked: Number(integ.sig_checked),
+    integrityKeyFp: keys.fingerprint ?? "",
+    integrityReasons: JSON.stringify(integ.reasons)
   };
   db.insert(runs).values(row).onConflictDoUpdate({ target: [runs.sourceId, runs.runId], set: row }).run();
 }
+var reasonsOf = (j) => {
+  try {
+    const x = JSON.parse(j ?? "[]");
+    return Array.isArray(x) ? x.filter((s) => typeof s === "string") : [];
+  } catch {
+    return [];
+  }
+};
 var parseRun = (r) => ({
   source_id: r.sourceId,
   run_id: r.runId,
@@ -5763,6 +5960,10 @@ var parseRun = (r) => ({
   last_event_at: r.lastEventAt,
   tampered: r.tampered === 1,
   conflict: r.conflict === 1,
+  attested: r.attested === 1,
+  sig_checked: r.sigChecked === 1,
+  integrity_reasons: reasonsOf(r.integrityReasons),
+  effective_verdict: effectiveVerdict({ verdict: r.verdict, tampered: r.tampered === 1, attested: r.attested === 1, sig_checked: r.sigChecked === 1 }),
   status: r.endedAt ? "completed" : "running",
   elapsed_s: elapsedS(r)
 });
@@ -5801,10 +6002,44 @@ var elapsedS = (r) => {
   const end = r.endedAt ? Date.parse(r.endedAt) : Date.now();
   return Math.max(0, (end - Date.parse(r.startedAt)) / 1000);
 };
+var SIG_SUFFIX = " (signature not checked)";
+var verdictFilter = (v) => {
+  if (!v)
+    return;
+  if (v === "TAMPERED")
+    return eq(runs.tampered, 1);
+  if (v === "UNVERIFIED")
+    return and(eq(runs.tampered, 0), sql`${runs.verdict} is not null`, sql`coalesce(${runs.attested}, 0) != 1`);
+  if (SUCCESS_VERDICTS.has(v))
+    return and(eq(runs.verdict, v), eq(runs.tampered, 0), eq(runs.attested, 1), eq(runs.sigChecked, 1));
+  if (v.endsWith(SIG_SUFFIX) && SUCCESS_VERDICTS.has(v.slice(0, -SIG_SUFFIX.length)))
+    return and(eq(runs.verdict, v.slice(0, -SIG_SUFFIX.length)), eq(runs.tampered, 0), eq(runs.attested, 1), sql`coalesce(${runs.sigChecked}, 0) != 1`);
+  return and(eq(runs.verdict, v), eq(runs.tampered, 0), eq(runs.attested, 1));
+};
+var RECOMPUTE_CHUNK = 200;
+function recomputeLegacy(db) {
+  const fp = pubkeysFromEnv().fingerprint ?? "";
+  let n = 0;
+  for (;; ) {
+    const rows = db.select({ s: runs.sourceId, r: runs.runId }).from(runs).where(sql`${runs.attested} is null or ${runs.integrityKeyFp} is not ${fp}`).limit(RECOMPUTE_CHUNK).all();
+    if (rows.length === 0)
+      return n;
+    db.transaction((tx) => {
+      const t = tx;
+      for (const x of rows) {
+        if (loadEvents(t, x.s, x.r).length === 0) {
+          t.update(runs).set({ attested: 0, sigChecked: 0, integrityKeyFp: fp, integrityReasons: JSON.stringify(["stored events are missing; integrity cannot be evaluated"]) }).where(and(eq(runs.sourceId, x.s), eq(runs.runId, x.r))).run();
+        } else
+          rebuildRun(t, x.s, x.r);
+      }
+    });
+    n += rows.length;
+  }
+}
 function listRuns(db, q) {
   const limit = Math.min(Math.max(q.limit ?? 50, 1), 200);
   const offset = Math.max(Number.parseInt(q.cursor ?? "0", 10) || 0, 0);
-  const where = and(q.verdict ? eq(runs.verdict, q.verdict) : undefined, q.repo ? eq(runs.originRepo, q.repo) : undefined, q.group_id ? eq(runs.groupId, q.group_id) : undefined, q.since ? gte(runs.startedAt, q.since) : undefined, q.until ? lt(runs.startedAt, q.until) : undefined);
+  const where = and(verdictFilter(q.verdict), q.repo ? eq(runs.originRepo, q.repo) : undefined, q.group_id ? eq(runs.groupId, q.group_id) : undefined, q.since ? gte(runs.startedAt, q.since) : undefined, q.until ? lt(runs.startedAt, q.until) : undefined);
   const total = db.select({ n: sql`count(*)` }).from(runs).where(where).get()?.n ?? 0;
   const rows = db.select().from(runs).where(where).orderBy(desc(runs.startedAt), asc(runs.runId)).limit(limit).offset(offset).all();
   return { runs: rows.map((r) => withLive(db, r)), total, next_cursor: offset + rows.length < total ? String(offset + rows.length) : null };
@@ -5860,7 +6095,7 @@ function ingest(db, body) {
     if (e.run !== runId)
       return { status: 400, body: { error: `events[${i}]: run does not match run_id` } };
     const json = JSON.stringify(e);
-    rows.push({ e, json, sha: createHash("sha256").update(json).digest("hex") });
+    rows.push({ e, json, sha: createHash2("sha256").update(json).digest("hex") });
   }
   const now = new Date().toISOString();
   let accepted = 0, duplicate = 0, conflict = 0;
@@ -5889,7 +6124,7 @@ function ingest(db, body) {
 }
 
 // src/server/auth.ts
-import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { createHash as createHash3, timingSafeEqual } from "crypto";
 var LOOPBACK_BINDS = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
 function isLoopbackHost(host) {
   return !!host && /^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i.test(host);
@@ -5898,8 +6133,8 @@ function tokenMatches(header, token) {
   const m = /^Bearer (.+)$/i.exec(header ?? "");
   if (!m)
     return false;
-  const a = createHash2("sha256").update(m[1] ?? "").digest();
-  const b = createHash2("sha256").update(token).digest();
+  const a = createHash3("sha256").update(m[1] ?? "").digest();
+  const b = createHash3("sha256").update(token).digest();
   return timingSafeEqual(a, b);
 }
 function bindRefusal(env) {
@@ -5933,12 +6168,240 @@ function tokenGuard(token) {
   };
 }
 
+// src/shipper/backfill.ts
+import { readdirSync } from "fs";
+import { join as join4 } from "path";
+
+// src/shipper/ship.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { hostname } from "os";
+import { join as join3 } from "path";
+var BATCH = 200;
+var MAX_BYTES = 800000;
+function sourceId(repoDir) {
+  let real2 = repoDir;
+  try {
+    real2 = realpathSync(repoDir);
+  } catch {}
+  return createHash4("sha256").update(`${hostname()}\x00${real2}`).digest("hex").slice(0, 16);
+}
+var redactDeep = (x) => typeof x === "string" ? redactSecrets(x) : Array.isArray(x) ? x.map(redactDeep) : x && typeof x === "object" ? Object.fromEntries(Object.entries(x).map(([k, v]) => [k, redactDeep(v)])) : x;
+var redactEvent = (e) => ({ ...e, data: redactDeep(e.data) });
+var backoffMs = (failures, rnd = Math.random) => Math.min(60000, 1000 * 2 ** Math.max(0, failures - 1)) * (1 + 0.25 * rnd());
+function readShip(runDir, url) {
+  try {
+    const s = JSON.parse(readFileSync3(join3(runDir, "ship.json"), "utf8"));
+    if (s.url === url && Number.isInteger(s.acked_seq))
+      return { acked_seq: s.acked_seq, url };
+  } catch {}
+  return { acked_seq: -1, url };
+}
+function writeShip(runDir, s) {
+  const tmp = join3(runDir, `ship.json.${process.pid}.tmp`);
+  writeFileSync2(tmp, JSON.stringify(s) + `
+`);
+  renameSync(tmp, join3(runDir, "ship.json"));
+}
+async function shipRun(o) {
+  const st = readShip(o.runDir, o.url);
+  const all = readEvents(join3(o.runDir, "events.jsonl"));
+  let lines = 0;
+  try {
+    lines = readFileSync3(join3(o.runDir, "events.jsonl"), "utf8").split(`
+`).filter((l) => l.trim() !== "").length;
+  } catch {}
+  const skipped = lines - all.length;
+  const todo = all.filter((e) => e.seq > st.acked_seq).sort((a, b) => a.seq - b.seq);
+  if (todo.length === 0)
+    return { ok: true, sent: 0, acked_seq: st.acked_seq, pending: 0 };
+  const run_id = todo[0].run;
+  const f = o.fetchImpl ?? fetch;
+  let sent = 0;
+  const fail = () => ({ ok: false, sent, acked_seq: st.acked_seq, pending: todo.length - sent });
+  for (let i = 0;i < todo.length; ) {
+    const batch = [];
+    for (let bytes = 0;i < todo.length && batch.length < BATCH; i++) {
+      bytes += JSON.stringify(todo[i]).length;
+      if (batch.length > 0 && bytes > MAX_BYTES)
+        break;
+      batch.push(redactEvent(todo[i]));
+    }
+    try {
+      const r = await f(`${o.url.replace(/\/+$/, "")}/v1/ingest`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...o.token ? { authorization: `Bearer ${o.token}` } : {} },
+        body: JSON.stringify({ source: o.source, run_id, events: batch }),
+        signal: AbortSignal.timeout(o.timeoutMs ?? 1e4)
+      });
+      if (!r.ok && r.status !== 409)
+        return fail();
+    } catch {
+      return fail();
+    }
+    st.acked_seq = batch[batch.length - 1].seq;
+    st.skipped = skipped;
+    sent += batch.length;
+    try {
+      writeShip(o.runDir, st);
+    } catch {
+      return fail();
+    }
+  }
+  return { ok: true, sent, acked_seq: st.acked_seq, pending: 0 };
+}
+var shipEnabled = (env) => env.LOKI_CONTROL_URL || null;
+var hasSpool = (runDir) => existsSync3(join3(runDir, "events.jsonl"));
+
+// src/shipper/backfill.ts
+async function backfill(o) {
+  const env = o.env ?? process.env;
+  const url = shipEnabled(env);
+  if (!url)
+    return { runs: 0, sent: 0, failed: [] };
+  const sleep = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const attempts = o.attempts ?? 3;
+  const root = join4(o.repoDir, ".loki", "runs");
+  let ids = [];
+  try {
+    ids = readdirSync(root).sort();
+  } catch {
+    return { runs: 0, sent: 0, failed: [] };
+  }
+  const source = sourceId(o.repoDir);
+  let runs2 = 0, sent = 0;
+  const failed = [];
+  for (const id of ids) {
+    const runDir = join4(root, id);
+    if (!hasSpool(runDir))
+      continue;
+    runs2++;
+    let res = { ok: false, sent: 0, acked_seq: -1, pending: 0 };
+    for (let a = 1;a <= attempts; a++) {
+      res = await shipRun({ runDir, url, source, token: env.LOKI_CONTROL_TOKEN, fetchImpl: o.fetchImpl });
+      sent += res.sent;
+      if (res.ok)
+        break;
+      if (a < attempts)
+        await sleep(backoffMs(a));
+    }
+    if (!res.ok)
+      failed.push(id);
+  }
+  return { runs: runs2, sent, failed };
+}
+
+// src/db/prune.ts
+var n = (sqlite, sql2, ...args) => sqlite.query(sql2).get(...args).n;
+function countFor(sqlite, keys) {
+  const bySource = new Map;
+  for (const k of keys)
+    bySource.set(k.source_id, [...bySource.get(k.source_id) ?? [], k.run_id]);
+  let events2 = 0, sources2 = 0;
+  for (const [src, runIds] of bySource) {
+    let ev = 0;
+    for (const r of runIds)
+      ev += n(sqlite, "select count(*) n from events where source_id = ? and run_id = ?", src, r);
+    events2 += ev;
+    const runsLeft = n(sqlite, "select count(*) n from runs where source_id = ?", src) - runIds.length;
+    const eventsLeft = n(sqlite, "select count(*) n from events where source_id = ?", src) - ev;
+    if (runsLeft <= 0 && eventsLeft <= 0 && sqlite.query("select 1 x from sources where id = ?").get(src))
+      sources2++;
+  }
+  return { runs: keys.length, events: events2, sources: sources2 };
+}
+function audit2(sqlite, action, actor, detail) {
+  sqlite.query("insert into audit (ts, action, actor, detail) values (?, ?, ?, ?)").run(new Date().toISOString(), action, actor, JSON.stringify(detail));
+}
+var dropOrphanSources = (sqlite, ids) => {
+  for (const id of ids)
+    sqlite.query("delete from sources where id = ? and not exists (select 1 from runs where source_id = ?) and not exists (select 1 from events where source_id = ?)").run(id, id, id);
+};
+function removeRun(sqlite, source, run, actor = "http") {
+  let out = null;
+  sqlite.transaction(() => {
+    if (!sqlite.query("select 1 x from runs where source_id = ? and run_id = ?").get(source, run))
+      return;
+    out = countFor(sqlite, [{ source_id: source, run_id: run }]);
+    audit2(sqlite, "run.remove", actor, { source_id: source, run_id: run, counts: out });
+    sqlite.query("delete from events where source_id = ? and run_id = ?").run(source, run);
+    sqlite.query("delete from runs where source_id = ? and run_id = ?").run(source, run);
+    dropOrphanSources(sqlite, [source]);
+  }).immediate();
+  return out;
+}
+
+// src/server/actions.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join5, resolve } from "path";
+var ISSUE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}\/[A-Za-z0-9._-]{1,100}#[1-9][0-9]{0,8}$/;
+var TASK = /^[A-Za-z0-9][A-Za-z0-9 .,_/#@+=-]{0,499}$/;
+var hasDotDot = (t) => t.split(/[\\/ ]/).some((seg) => seg.startsWith(".."));
+function childEnv(env = process.env) {
+  const e = { ...env, LOKI_NO_BROWSER: "1" };
+  for (const k of ["LOKI_CONTROL_TOKEN", "LOKI_CONTROL_DB", "LOKI_CONTROL_HOST", "PORT"])
+    delete e[k];
+  return e;
+}
+function registryRepos(env = process.env) {
+  try {
+    const j = JSON.parse(readFileSync4(join5(env.HOME || homedir2(), ".loki", "dashboard", "projects.json"), "utf8"));
+    return Object.values(j.projects ?? {}).map((p) => typeof p?.path === "string" ? p.path : "").filter((p) => p && existsSync4(p) && statSync(p).isDirectory());
+  } catch {
+    return [];
+  }
+}
+function planStart(body, known, bin = "loki") {
+  const b = body && typeof body === "object" ? body : {};
+  if (typeof b.target !== "string")
+    return { ok: false, error: "target must be a string" };
+  const target = b.target.trim();
+  const issue = ISSUE.test(target);
+  if (!issue && !TASK.test(target))
+    return { ok: false, error: "target must be owner/repo#N or a plain task (letters, digits, spaces, . , _ / # @ + = -)" };
+  if (hasDotDot(target))
+    return { ok: false, error: "target must not contain a .. path segment" };
+  let cwd = process.cwd();
+  if (b.repo !== undefined && b.repo !== "") {
+    if (typeof b.repo !== "string" || b.repo.includes("\x00"))
+      return { ok: false, error: "repo must be a path string" };
+    const want = resolve(b.repo);
+    const hit = known.map((k) => resolve(k)).find((k) => k === want);
+    if (!hit)
+      return { ok: false, error: "repo is not a known project" };
+    cwd = hit;
+  }
+  return { ok: true, argv: issue ? [bin, "start", target] : [bin, "start", "--brief", target], cwd };
+}
+function spawnStart(argv, cwd, onExit = () => {}) {
+  return new Promise((done) => {
+    try {
+      const [cmd, ...args] = argv;
+      const child = spawn(cmd, args, { cwd, detached: true, stdio: "ignore", shell: false, env: childEnv() });
+      child.once("exit", onExit);
+      child.once("error", (e) => {
+        onExit();
+        done({ error: `could not start loki: ${e.message}` });
+      });
+      child.once("spawn", () => {
+        child.unref();
+        done({ pid: child.pid ?? 0 });
+      });
+    } catch (e) {
+      done({ error: `could not start loki: ${e.message}` });
+    }
+  });
+}
+
 // src/server/app.ts
 var MAX_BODY = 1e6;
-var defaultUiDir = () => [join3(import.meta.dir, "../../ui/dist"), join3(import.meta.dir, "../ui/dist")].find((d) => existsSync2(join3(d, "index.html")));
+var defaultUiDir = () => [join6(import.meta.dir, "../../ui/dist"), join6(import.meta.dir, "../ui/dist")].find((d) => existsSync5(join6(d, "index.html")));
 function createApp(opts) {
   const uiDir = opts.uiDir ?? defaultUiDir();
   const { db, sqlite } = openDb(opts.dbPath);
+  recomputeLegacy(db);
   let ready = true;
   const answerDir = opts.answerDir ?? defaultAnswerDir();
   const app = new Hono3;
@@ -6006,6 +6469,71 @@ function createApp(opts) {
     const r = writeAnswer(answerDir, source, run, body?.answer);
     return c.json(r.body, r.status);
   });
+  const act = opts.loopbackOnly ? app : new Hono3;
+  const peerIsLoopback = (c) => {
+    const ip = c.env?.requestIP?.(c.req.raw)?.address;
+    return typeof ip === "string" && /^(127\.\d+\.\d+\.\d+|::1|::ffff:127\.\d+\.\d+\.\d+)$/.test(ip);
+  };
+  const local = (c) => peerIsLoopback(c) && isLoopbackHost(c.req.header("host")) && (c.req.header("content-type") ?? "").toLowerCase().startsWith("application/json");
+  const repoDir = opts.repoDir ?? process.cwd();
+  const inflight = new Set;
+  act.post("/v1/import", async (c) => {
+    if (!local(c))
+      return c.json({ error: "loopback JSON requests only" }, 403);
+    const r = await backfill({
+      repoDir,
+      env: { LOKI_CONTROL_URL: "http://127.0.0.1", LOKI_CONTROL_TOKEN: opts.token },
+      fetchImpl: (u, init) => app.fetch(new Request(u, { ...init, headers: { ...init.headers, host: "127.0.0.1" } }))
+    });
+    return c.json({ runs: r.runs, sent: r.sent, failed: r.failed });
+  });
+  act.delete("/v1/runs/:source/:run", async (c) => {
+    if (!peerIsLoopback(c) || !isLoopbackHost(c.req.header("host")))
+      return c.json({ error: "loopback only" }, 403);
+    if (!(c.req.header("content-type") ?? "").toLowerCase().startsWith("application/json"))
+      return c.json({ error: "content-type must be application/json" }, 400);
+    const origin = c.req.header("origin");
+    if (origin !== undefined) {
+      let oh = "";
+      try {
+        oh = new URL(origin).host.toLowerCase();
+      } catch {}
+      if (!oh || oh !== (c.req.header("host") ?? "").toLowerCase())
+        return c.json({ error: "origin not allowed" }, 403);
+    }
+    const source = c.req.param("source"), run = c.req.param("run");
+    const r = removeRun(sqlite, source, run);
+    if (!r)
+      return c.json({ error: "run not found" }, 404);
+    const left = sqlite.query("select count(*) n from runs").get().n;
+    return c.json({ ok: true, removed: r, remaining_runs: left });
+  });
+  act.get("/v1/repos", (c) => peerIsLoopback(c) ? c.json({ repos: [...new Set([repoDir, ...registryRepos()])] }) : c.json({ error: "loopback only" }, 403));
+  act.post("/v1/start", async (c) => {
+    if (!local(c))
+      return c.json({ error: "loopback JSON requests only" }, 403);
+    const text2 = await c.req.text();
+    if (text2.length > 20000)
+      return c.json({ error: "body too large" }, 413);
+    let body;
+    try {
+      body = JSON.parse(text2);
+    } catch {
+      return c.json({ error: "invalid JSON" }, 400);
+    }
+    const plan = planStart(body, [repoDir, ...registryRepos()], opts.startBin);
+    if (!plan.ok)
+      return c.json({ error: plan.error }, 400);
+    if (inflight.has(plan.cwd))
+      return c.json({ error: "a run is already starting or running in this repo" }, 409);
+    inflight.add(plan.cwd);
+    const r = await (opts.spawnImpl ?? spawnStart)(plan.argv, plan.cwd, () => inflight.delete(plan.cwd));
+    if ("error" in r) {
+      inflight.delete(plan.cwd);
+      return c.json({ error: r.error }, 500);
+    }
+    return c.json({ ok: true, pid: r.pid, command: plan.argv.slice(1).join(" ") });
+  });
   app.get("/v1/runs/:id", (c) => {
     const id = c.req.param("id");
     const i = id.indexOf(":");
@@ -6020,13 +6548,13 @@ function createApp(opts) {
     }
     if (!uiDir || p.startsWith("/v1/"))
       return c.json({ error: "not found" }, 404);
-    const root = resolve(uiDir);
-    const f = resolve(root, `.${p}`);
-    if (f.startsWith(root + sep) && existsSync2(f) && statSync(f).isFile())
+    const root = resolve2(uiDir);
+    const f = resolve2(root, `.${p}`);
+    if (f.startsWith(root + sep) && existsSync5(f) && statSync2(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(join3(root, "index.html")));
+    return new Response(Bun.file(join6(root, "index.html")));
   });
   return { app, db, close: () => sqlite.close() };
 }