loki-mode 10.7.0 → 10.7.1

package/loki-ts/package.json

@@ -10,6 +10,7 @@
   },
   "scripts": {
     "version": "bun src/cli.ts version",
+    "postinstall": "cd ../packages/control-plane && bun install --frozen-lockfile",
     "typecheck": "bun run --bun tsc --noEmit",
     "test": "LOKI_NO_BROWSER=1 bun test",
     "bench": "bun run scripts/bench.ts",

package/mcp/__init__.py

@@ -75,4 +75,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '10.7.0'
+__version__ = '10.7.1'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "10.7.0",
+  "version": "10.7.1",
   "description": "An autonomous software factory that knows what it is supposed to deliver, and proves it did.",
   "keywords": [
     "agent",

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

@@ -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,7 +5574,7 @@ 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";
@@ -5718,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) {
@@ -5727,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;
@@ -5756,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,
@@ -5786,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)
 });
@@ -5824,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 };
@@ -5883,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;
@@ -5912,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);
@@ -5921,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) {
@@ -5961,8 +6173,8 @@ import { readdirSync } from "fs";
 import { join as join4 } from "path";
 
 // src/shipper/ship.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync as writeFileSync2 } from "fs";
+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;
@@ -5972,14 +6184,14 @@ function sourceId(repoDir) {
   try {
     real2 = realpathSync(repoDir);
   } catch {}
-  return createHash3("sha256").update(`${hostname()}\x00${real2}`).digest("hex").slice(0, 16);
+  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(readFileSync2(join3(runDir, "ship.json"), "utf8"));
+    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 {}
@@ -5996,7 +6208,7 @@ async function shipRun(o) {
   const all = readEvents(join3(o.runDir, "events.jsonl"));
   let lines = 0;
   try {
-    lines = readFileSync2(join3(o.runDir, "events.jsonl"), "utf8").split(`
+    lines = readFileSync3(join3(o.runDir, "events.jsonl"), "utf8").split(`
 `).filter((l) => l.trim() !== "").length;
   } catch {}
   const skipped = lines - all.length;
@@ -6079,9 +6291,49 @@ async function backfill(o) {
   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 readFileSync3, statSync } from "fs";
+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}$/;
@@ -6095,7 +6347,7 @@ function childEnv(env = process.env) {
 }
 function registryRepos(env = process.env) {
   try {
-    const j = JSON.parse(readFileSync3(join5(env.HOME || homedir2(), ".loki", "dashboard", "projects.json"), "utf8"));
+    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 [];
@@ -6149,6 +6401,7 @@ var defaultUiDir = () => [join6(import.meta.dir, "../../ui/dist"), join6(import.
 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;
@@ -6234,6 +6487,27 @@ function createApp(opts) {
     });
     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))

package/packages/control-plane/drizzle/0002_tiresome_fixer.sql

@@ -0,0 +1,7 @@
+CREATE TABLE `audit` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`ts` text NOT NULL,
+	`action` text NOT NULL,
+	`actor` text NOT NULL,
+	`detail` text NOT NULL
+);

package/packages/control-plane/drizzle/0003_integrity.sql

@@ -0,0 +1,4 @@
+ALTER TABLE `runs` ADD `attested` integer;--> statement-breakpoint
+ALTER TABLE `runs` ADD `sig_checked` integer;--> statement-breakpoint
+ALTER TABLE `runs` ADD `integrity_key_fp` text;--> statement-breakpoint
+ALTER TABLE `runs` ADD `integrity_reasons` text;