loki-mode 10.7.0 → 10.7.1

package/packages/control-plane/drizzle/meta/0003_snapshot.json

@@ -0,0 +1,437 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "c1492d55-5d08-4208-940a-38fba6b33b3c",
+  "prevId": "2b4a930a-5fb1-4e32-8387-fac651ba5fca",
+  "tables": {
+    "audit": {
+      "name": "audit",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "ts": {
+          "name": "ts",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor": {
+          "name": "actor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "detail": {
+          "name": "detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "events": {
+      "name": "events",
+      "columns": {
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "run_id": {
+          "name": "run_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "seq": {
+          "name": "seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ts": {
+          "name": "ts",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stage": {
+          "name": "stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "line_sha256": {
+          "name": "line_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "received_at": {
+          "name": "received_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "events_run_seq": {
+          "name": "events_run_seq",
+          "columns": [
+            "run_id",
+            "seq"
+          ],
+          "isUnique": false
+        },
+        "events_type_ts": {
+          "name": "events_type_ts",
+          "columns": [
+            "type",
+            "ts"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "events_source_id_run_id_seq_pk": {
+          "columns": [
+            "source_id",
+            "run_id",
+            "seq"
+          ],
+          "name": "events_source_id_run_id_seq_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "runs": {
+      "name": "runs",
+      "columns": {
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "run_id": {
+          "name": "run_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin_repo": {
+          "name": "origin_repo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "issue_ref": {
+          "name": "issue_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "task_source": {
+          "name": "task_source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "verdict": {
+          "name": "verdict",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pr_url": {
+          "name": "pr_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pr_draft": {
+          "name": "pr_draft",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_usd": {
+          "name": "cost_usd",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "partial_usd": {
+          "name": "partial_usd",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "measured_sessions": {
+          "name": "measured_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "total_sessions": {
+          "name": "total_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "input_tokens": {
+          "name": "input_tokens",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "output_tokens": {
+          "name": "output_tokens",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "wall_s": {
+          "name": "wall_s",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_seq": {
+          "name": "last_seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_event_at": {
+          "name": "last_event_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "tampered": {
+          "name": "tampered",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "conflict": {
+          "name": "conflict",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "unit_id": {
+          "name": "unit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attested": {
+          "name": "attested",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "integrity_reasons": {
+          "name": "integrity_reasons",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sig_checked": {
+          "name": "sig_checked",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "integrity_key_fp": {
+          "name": "integrity_key_fp",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "runs_started": {
+          "name": "runs_started",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        },
+        "runs_verdict": {
+          "name": "runs_verdict",
+          "columns": [
+            "verdict"
+          ],
+          "isUnique": false
+        },
+        "runs_group": {
+          "name": "runs_group",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "runs_source_id_run_id_pk": {
+          "columns": [
+            "source_id",
+            "run_id"
+          ],
+          "name": "runs_source_id_run_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "sources": {
+      "name": "sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "first_seen": {
+          "name": "first_seen",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/packages/control-plane/drizzle/meta/_journal.json

@@ -15,6 +15,20 @@
       "when": 1790956800000,
       "tag": "0001_group_id",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1791046012148,
+      "tag": "0002_tiresome_fixer",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1791132412148,
+      "tag": "0003_integrity",
+      "breakpoints": true
     }
   ]
 }

package/packages/control-plane/src/db/migrate.ts

@@ -12,8 +12,12 @@ export function openDb(path: string) {
   const sqlite = new Database(path, { create: true });
   sqlite.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
   const db = drizzle(sqlite, { schema });
-  // src/db/ (source) and dist/ (bundled server) sit at different depths under packages/control-plane
-  const migrationsFolder = [join(import.meta.dir, "../../drizzle"), join(import.meta.dir, "../drizzle")].find((d) => existsSync(join(d, "meta/_journal.json")));
+  // source, the bundled server and the bundled CLI sit at different depths
+  const migrationsFolder = [
+    join(import.meta.dir, "../../drizzle"), // src/db (source checkout)
+    join(import.meta.dir, "../drizzle"), // packages/control-plane/dist (bundled server)
+    join(import.meta.dir, "../../packages/control-plane/drizzle"), // loki-ts/dist (bundled CLI; also an installed npm package)
+  ].find((d) => existsSync(join(d, "meta/_journal.json")));
   if (!migrationsFolder) throw new Error("drizzle migrations folder not found");
   migrate(db, { migrationsFolder });
   return { db, sqlite };

package/packages/control-plane/src/db/prune.ts

@@ -0,0 +1,91 @@
+// Removal of runs from the control DB: shared by `loki control prune` (direct DB) and DELETE /v1/runs/:source/:run (server).
+// One transaction deletes the runs, their events, and any source left with neither. An audit row is written first, inside the same transaction.
+import { Database } from "bun:sqlite";
+
+export interface PruneFilter { repo?: string; before?: string }
+export interface PruneCounts { runs: number; events: number; sources: number }
+
+/** Strict ISO 8601 parse: YYYY-MM-DD or a date-time with an explicit Z/offset. Returns a normalized UTC instant or null. */
+export function parseBefore(s: string): string | null {
+  if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2}))?$/.test(s)) return null;
+  const t = Date.parse(s);
+  if (Number.isNaN(t)) return null;
+  // reject rolled-over dates such as 2026-02-31
+  if (new Date(`${s.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) !== s.slice(0, 10)) return null;
+  return new Date(t).toISOString();
+}
+
+type Key = { source_id: string; run_id: string };
+
+function where(f: PruneFilter): { sql: string; args: string[] } {
+  const parts: string[] = [];
+  const args: string[] = [];
+  if (f.repo !== undefined) { parts.push("origin_repo = ?"); args.push(f.repo); }
+  if (f.before !== undefined) { parts.push("started_at IS NOT NULL AND julianday(started_at) < julianday(?)"); args.push(f.before); }
+  return { sql: parts.join(" AND "), args };
+}
+
+const n = (sqlite: Database, sql: string, ...args: string[]): number => (sqlite.query(sql).get(...args) as { n: number }).n;
+
+/** What deleting these runs would remove: runs, their events, and sources that would be left holding nothing. */
+function countFor(sqlite: Database, keys: Key[]): PruneCounts {
+  const bySource = new Map<string, string[]>();
+  for (const k of keys) bySource.set(k.source_id, [...(bySource.get(k.source_id) ?? []), k.run_id]);
+  let events = 0, sources = 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);
+    events += 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)) sources++;
+  }
+  return { runs: keys.length, events, sources };
+}
+
+export function audit(sqlite: Database, action: string, actor: string, detail: unknown): void {
+  sqlite.query("insert into audit (ts, action, actor, detail) values (?, ?, ?, ?)").run(new Date().toISOString(), action, actor, JSON.stringify(detail));
+}
+
+/** Drops only the given sources, and only when they now hold neither runs nor events (matches what countFor reported). */
+const dropOrphanSources = (sqlite: Database, ids: Iterable<string>): void => {
+  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);
+};
+
+/** Read-only handle for dry runs: no migrations, no journal-mode change, no writes. */
+export const openReadOnly = (path: string): Database => new Database(path, { readonly: true });
+
+/** Removes the matching runs. dryRun counts only and writes nothing. At least one filter is required. */
+export function pruneRuns(sqlite: Database, f: PruneFilter, opts: { dryRun?: boolean; actor?: string } = {}): PruneCounts {
+  if (f.repo === undefined && f.before === undefined) throw new Error("prune needs --repo or --before");
+  const w = where(f);
+  const select = (): Key[] => sqlite.query(`select source_id, run_id from runs where ${w.sql}`).all(...w.args) as Key[];
+  if (opts.dryRun) return countFor(sqlite, select());
+  let out: PruneCounts = { runs: 0, events: 0, sources: 0 };
+  sqlite.transaction(() => {
+    const keys = select();
+    if (keys.length === 0) return;
+    out = countFor(sqlite, keys);
+    audit(sqlite, "prune", opts.actor ?? "cli", { filter: f, counts: out });
+    for (const k of keys) {
+      sqlite.query("delete from events where source_id = ? and run_id = ?").run(k.source_id, k.run_id);
+      sqlite.query("delete from runs where source_id = ? and run_id = ?").run(k.source_id, k.run_id);
+    }
+    dropOrphanSources(sqlite, new Set(keys.map((k) => k.source_id)));
+  }).immediate();
+  return out;
+}
+
+/** Removes one run. Null when it does not exist (nothing audited, nothing deleted). Otherwise the counts removed. */
+export function removeRun(sqlite: Database, source: string, run: string, actor = "http"): PruneCounts | null {
+  let out: PruneCounts | null = 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 }]);
+    audit(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;
+}

package/packages/control-plane/src/db/schema.ts

@@ -49,9 +49,22 @@ export const runs = sqliteTable("runs", {
   conflict: integer("conflict").notNull().default(0),
   groupId: text("group_id"),
   unitId: text("unit_id"),
+  attested: integer("attested"), // EL-FC08b: null = never evaluated (reads as unattested)
+  sigChecked: integer("sig_checked"), // log seal signature verified against a configured key
+  integrityKeyFp: text("integrity_key_fp"), // key-set fingerprint the integrity result was computed under; a change triggers a boot recompute
+  integrityReasons: text("integrity_reasons"), // JSON string[]
 }, (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),
 ]);
+
+// Append-only record of destructive operator actions (run removal, prune). Written before the delete runs.
+export const 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(),
+});

package/packages/control-plane/src/server/app.ts

@@ -4,9 +4,10 @@ import { Hono, type Context } from "hono";
 import { openDb } from "../db/migrate.ts";
 import { ingest } from "./ingest.ts";
 import { defaultAnswerDir, writeAnswer } from "./answer.ts";
-import { listRuns, runDetail } from "./runs.ts";
+import { listRuns, recomputeLegacy, runDetail } from "./runs.ts";
 import { hostGuard, isLoopbackHost, tokenGuard } from "./auth.ts";
 import { backfill } from "../shipper/backfill.ts";
+import { removeRun } from "../db/prune.ts";
 import { planStart, registryRepos, spawnStart } from "./actions.ts";
 
 const MAX_BODY = 1_000_000;
@@ -18,6 +19,7 @@ const defaultUiDir = () => [join(import.meta.dir, "../../ui/dist"), join(import.
 export function createApp(opts: { dbPath: string; uiDir?: string; answerDir?: string; token?: string; loopbackOnly?: boolean; repoDir?: string; startBin?: string; spawnImpl?: typeof spawnStart }) {
   const uiDir = opts.uiDir ?? defaultUiDir();
   const { db, sqlite } = openDb(opts.dbPath);
+  recomputeLegacy(db);
   let ready = true;
   const answerDir = opts.answerDir ?? defaultAnswerDir();
   const app = new Hono();
@@ -87,6 +89,23 @@ export function createApp(opts: { dbPath: string; uiDir?: string; answerDir?: st
     });
     return c.json({ runs: r.runs, sent: r.sent, failed: r.failed });
   });
+  // Remove one run (and its events). Loopback-only like /v1/start (never registered on a non-loopback server); bearer via tokenGuard when a token is set. JSON content type blocks cross-site form posts;
+  // a browser Origin must match the host this server is served on. Absent Origin (curl, the CLI) is allowed. The audit row is written inside the delete transaction, before the rows go.
+  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 { /* refused below */ }
+      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() as { n: number }).n;
+    return c.json({ ok: true, removed: r, remaining_runs: left });
+  });
   act.get("/v1/repos", (c) => peerIsLoopback(c) ? c.json({ repos: [...new Set<string>([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);