@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/src/history/source-watches.ts

@@ -0,0 +1,156 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { identity } from "./source-file.ts";
+import type { SourceRow } from "./rows.ts";
+
+interface WatchEvents {
+  readonly run: (id: string) => void;
+  readonly source: (id: string) => void;
+  readonly schedule: () => void;
+}
+/** Owns native handles, physical-directory identity and co-located run/source subscriptions. */
+export class SourceWatches {
+  private readonly runs = new Set<string>();
+  private readonly watchers = new Map<string, fs.FSWatcher>();
+  private readonly sourceWatchers = new Map<string, fs.FSWatcher>();
+  private readonly identities = new WeakMap<fs.FSWatcher, string>();
+  private readonly sources = new Map<string, Map<string, string>>();
+  private readonly root: string;
+  private readonly events: WatchEvents;
+  constructor(agentDir: string, events: WatchEvents) {
+    this.root = path.join(agentDir, "sessions", "subagent-runs");
+    this.events = events;
+  }
+  private handle(
+    directory: string,
+    recursive: boolean,
+    listener: (name: string | null) => void,
+    source = false,
+  ): void {
+    const handles = source ? this.sourceWatchers : this.watchers;
+    const existing = handles.get(directory);
+    try {
+      const physical = identity(fs.statSync(directory, { bigint: true }));
+      if (existing && this.identities.get(existing) === physical) {
+        return;
+      }
+      const watcher = fs.watch(directory, { recursive }, (event, name) => {
+        const filename = name?.toString() ?? null;
+        const selfRename = event === "rename" && filename === path.basename(directory);
+        if (selfRename && handles.get(directory) === watcher) {
+          this.identities.delete(watcher);
+          this.handle(directory, recursive, listener, source);
+          listener(null);
+        } else {
+          listener(filename);
+        }
+        if (!source) {
+          this.notifySources(directory, selfRename ? null : filename);
+        }
+        this.events.schedule();
+      });
+      this.identities.set(watcher, physical);
+      this.retireOnClose(directory, watcher, source);
+      handles.set(directory, watcher);
+      // Native close fences macOS re-registration; admit the replacement first.
+      existing?.close();
+    } catch {
+      if (existing && handles.get(directory) === existing) {
+        this.identities.delete(existing);
+      }
+      // Known-handle census recovers absent directories and dropped native watches.
+    }
+  }
+  private retireOnClose(directory: string, watcher: Readonly<fs.FSWatcher>, source: boolean): void {
+    const handles = source ? this.sourceWatchers : this.watchers;
+    const retire = () => {
+      if (handles.get(directory) === watcher) {
+        handles.delete(directory);
+      }
+    };
+    watcher.on("error", () => {
+      watcher.close();
+      retire();
+    });
+    watcher.on("close", retire);
+  }
+  private reset(directory: string): void {
+    for (const handles of [this.watchers, this.sourceWatchers]) {
+      const watcher = handles.get(directory);
+      if (watcher) {
+        this.identities.delete(watcher);
+      }
+    }
+    for (const id of this.sources.get(directory)?.keys() ?? []) {
+      this.events.source(id);
+    }
+  }
+  private notifySources(directory: string, name: string | null): void {
+    for (const [id, filename] of this.sources.get(directory) ?? []) {
+      if (name === null || name.length === 0 || filename === name) {
+        this.events.source(id);
+      }
+    }
+  }
+  sourceDirectory(directory: string): void {
+    if (!this.sources.has(directory) || this.watchers.has(directory)) {
+      return;
+    }
+    this.handle(
+      directory,
+      false,
+      (name) => {
+        this.notifySources(directory, name);
+      },
+      true,
+    );
+  }
+  install(runIds: readonly string[], sources: readonly Pick<SourceRow, "id" | "path">[]): void {
+    for (const id of runIds) {
+      this.runs.add(id);
+    }
+    // Observe only admitted trees. Foreign run directory churn never causes a global scan.
+    this.handle(this.root, false, (name) => {
+      let ids: Iterable<string> = this.runs;
+      if (name !== null && name.length > 0) {
+        ids = this.runs.has(name) ? [name] : [];
+      }
+      for (const id of ids) {
+        this.reset(path.join(this.root, id));
+        this.events.run(id);
+      }
+    });
+    for (const id of runIds) {
+      const directory = path.join(this.root, id);
+      this.handle(directory, true, (name) => {
+        if (name === null || name.length === 0) {
+          this.reset(directory);
+        }
+        this.events.run(id);
+      });
+      this.sourceDirectory(directory);
+    }
+    for (const source of sources) {
+      const directory = path.dirname(source.path);
+      let linked = this.sources.get(directory);
+      if (!linked) {
+        linked = new Map();
+        this.sources.set(directory, linked);
+      }
+      linked.set(source.id, path.basename(source.path));
+      this.sourceDirectory(directory);
+    }
+  }
+  forget(source: Pick<SourceRow, "id" | "path">): void {
+    this.sources.get(path.dirname(source.path))?.delete(source.id);
+  }
+  close(): void {
+    for (const watcher of [...this.watchers.values(), ...this.sourceWatchers.values()]) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.sourceWatchers.clear();
+    this.sources.clear();
+    this.runs.clear();
+  }
+}

package/src/history/store.ts

@@ -1,203 +1,316 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import type { DatabaseSync, SQLInputValue } from "node:sqlite";
-import { historyDirectory, historyTransaction, openHistoryDatabase } from "./database.ts";
-import { stripTerminalSequences } from "../shared/native-tui.ts";
-import { HistoryIndexError } from "./types.ts";
-import { readSavedOutput } from "./canonical-result.ts";
-import type { HistoryEntry, HistoryFreshness, HistoryRunRow, HistoryVersion } from "./types.ts";
+import { openGeneration } from "./database-generation.ts";
+import { OutputDigests } from "./output-digests.ts";
+import type { DatabaseSync } from "node:sqlite";
+import { historyTransaction, openHistoryDatabase } from "./database.ts";
+import { hash, safeText, hasText } from "./text.ts";
+export { hash, exactTextDigest, safeText, integer, pageLimit } from "./text.ts";
+import {
+  HistoryIndexError,
+  type HistoryEntry,
+  type HistoryFreshness,
+  type HistoryRunRow,
+  type HistoryVersion,
+  type HistoryIndexStatus,
+} from "./types.ts";
+import {
+  sourceRow,
+  indexRow,
+  type Row,
+  type IndexInput,
+  type SourceRow,
+  type EntryRow,
+  number,
+  text,
+} from "./rows.ts";
+import { parseObject, errorMessage } from "./values.ts";
 
-export const hash = (text: string | Buffer): string => createHash("sha256").update(text).digest("hex");
-export const exactTextDigest = (text: string): string => hash(stripTerminalSequences(text).trim());
-export const safeText = (value: unknown, limit = 1024): string => typeof value === "string" ? value.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b\[[0-?]*[ -/]*[@-~]|[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "").slice(0, limit) : "";
-export function integer(value: unknown, fallback: number, maximum = Number.MAX_SAFE_INTEGER): number {
-	const result = value === undefined ? fallback : value;
-	if (!Number.isSafeInteger(result) || Number(result) < 0 || Number(result) > maximum) throw new HistoryIndexError("INVALID", "Expected a bounded non-negative integer.");
-	return Number(result);
-}
-export function pageLimit(value: unknown, fallback = 100): number {
-	const limit = integer(value, fallback, 100);
-	if (!limit) throw new HistoryIndexError("INVALID", "Page limit must be from 1 to 100.");
-	return limit;
-}
-export interface SourceRow {
-	id: string; path: string; generation: number; identity: string | null; stamp: string | null;
-	session_id: string | null; header_digest: string | null; cursor: number; prefix_digest: string | null;
-	state: string; error: string | null; malformed: number; complexity: number; checked_at: number | null; format_version: number | null;
+export type { SourceRow, EntryRow } from "./rows.ts";
+export class HistoryStore {
+  readonly db: DatabaseSync;
+  readonly generation: string;
+  readonly file: string;
+  readonly owner: string;
+  private readonly counters = {
+    sourceChecks: 0,
+    sourceOpens: 0,
+    sourceBytesRead: 0,
+    runProjections: 0,
+    queries: 0,
+  };
+  get operations(): Readonly<typeof this.counters> {
+    return { ...this.counters };
+  }
+  count(operation: keyof typeof this.counters, amount = 1): void {
+    this.counters[operation] += amount;
+  }
+  private ingestLock?: DatabaseSync;
+  private readonly outputDigests = new OutputDigests();
+  constructor(agentDir: string, owner: string) {
+    this.owner = owner;
+    const { db, file } = openGeneration(agentDir, owner);
+    this.db = db;
+    this.file = file;
+    try {
+      this.generation = text(
+        this.require("SELECT value FROM meta WHERE key='generation'"),
+        "value",
+      );
+      this.db.exec(
+        "CREATE TEMP TABLE pending_text(field TEXT, position INTEGER, end_position INTEGER, text TEXT)",
+      );
+    } catch (error) {
+      this.db.close();
+      throw error;
+    }
+  }
+  require(sql: string, ...params: readonly IndexInput[]): Row {
+    const row = this.get(sql, ...params);
+    if (!row) {
+      throw new HistoryIndexError("CORRUPT", "Missing required index row.");
+    }
+    return row;
+  }
+  get(sql: string, ...params: readonly IndexInput[]): Row | undefined {
+    const row = this.db.prepare(sql).get(...params);
+    return row === undefined ? undefined : indexRow(row);
+  }
+  all(sql: string, ...params: readonly IndexInput[]): readonly Row[] {
+    return this.db
+      .prepare(sql)
+      .all(...params)
+      .map(indexRow);
+  }
+  run(
+    sql: string,
+    ...params: readonly IndexInput[]
+  ): ReturnType<ReturnType<DatabaseSync["prepare"]>["run"]> {
+    return this.db.prepare(sql).run(...params);
+  }
+  deleteDocuments(sourceId: string, unpublishedOnly = false): void {
+    const where = `entry_rowid IN (SELECT rowid FROM entries WHERE source_id=?${unpublishedOnly ? " AND published=0" : ""})`;
+    this.run(
+      `DELETE FROM corpus WHERE rowid IN (SELECT id FROM documents WHERE ${where})`,
+      sourceId,
+    );
+    this.run(`DELETE FROM documents WHERE ${where}`, sourceId);
+  }
+  transaction<T>(work: () => T): T {
+    return historyTransaction(this.db, work);
+  }
+  bump(): void {
+    this.run("UPDATE meta SET value=CAST(value AS INTEGER)+1 WHERE key='version'");
+    this.run("UPDATE meta SET value=? WHERE key='indexedAt'", String(Date.now()));
+  }
+  source(id: string): SourceRow | undefined {
+    const row = this.get("SELECT * FROM sources WHERE id=?", id);
+    return row ? sourceRow(row) : undefined;
+  }
+  resetSource(id: string, state = "pending", error: string | null = null): void {
+    this.transaction(() => {
+      this.deleteDocuments(id);
+      this.run("DELETE FROM entries WHERE source_id=?", id);
+      this.run(
+        "UPDATE sources SET generation=generation+1,identity=NULL,stamp=NULL,session_id=NULL,header_digest=NULL,format_version=NULL,cursor=0,prefix_digest=NULL,state=?,error=?,malformed=0,complexity=0,checked_at=? WHERE id=?",
+        state,
+        error,
+        Date.now(),
+        id,
+      );
+      this.bump();
+    });
+  }
+  clearUnpublished(id: string): void {
+    this.transaction(() => {
+      this.deleteDocuments(id, true);
+      this.run("DELETE FROM entries WHERE source_id=? AND published=0", id);
+    });
+  }
+  putView(view: HistoryRunRow, full: HistoryRunRow = view): void {
+    const attention = attentionRank(view);
+    const json = JSON.stringify(view),
+      filters = new Map(
+        full.children.map((child) => [
+          child.index,
+          safeText(
+            `${child.agent} ${child.label ?? ""} ${child.task ?? full.task}`,
+            Infinity,
+          ).toLowerCase(),
+        ]),
+      );
+    const filterText = safeText(
+      `${full.task} ${[...filters.values()].join(" ")}`,
+      Infinity,
+    ).toLowerCase();
+    const digests = new Map(
+      full.children.map((child) => [child.index, this.outputDigests.read(child.result)]),
+    );
+    const saved = this.get("SELECT view,filter_text FROM runs WHERE id=?", view.runId);
+    if (
+      saved?.view === json &&
+      saved.filter_text === filterText &&
+      this.all("SELECT child_index,output_digest FROM children WHERE run_id=?", view.runId).every(
+        (child) => child.output_digest === digests.get(number(child, "child_index")),
+      )
+    ) {
+      return;
+    }
+    this.transaction(() => {
+      this.run(
+        "INSERT INTO runs VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET attention=excluded.attention,updated=excluded.updated,negative_updated=excluded.negative_updated,state=excluded.state,filter_text=excluded.filter_text,view=excluded.view,predecessor_id=excluded.predecessor_id,predecessor_index=excluded.predecessor_index",
+        view.runId,
+        attention,
+        view.updatedAt,
+        -view.updatedAt,
+        view.state,
+        filterText,
+        json,
+        view.predecessorRunId ?? null,
+        view.predecessorIndex ?? 0,
+      );
+      this.putChildren(view, filters, digests);
+      this.bump();
+    });
+  }
+  private putChildren(
+    view: HistoryRunRow,
+    filters: Readonly<ReadonlyMap<number, string>>,
+    digests: Readonly<ReadonlyMap<number, string | null>>,
+  ): void {
+    this.run("DELETE FROM children WHERE run_id=?", view.runId);
+    for (const child of view.children) {
+      let source: string | null = null;
+      if (hasText(child.sessionFile)) {
+        const file = path.resolve(child.sessionFile);
+        source = hash(file);
+        this.run(
+          "INSERT INTO sources(id,path) VALUES (?,?) ON CONFLICT(id) DO NOTHING",
+          source,
+          file,
+        );
+      }
+      const terminal = child.state !== "live" && child.state !== "unknown";
+      const boundary = terminalBoundary(child, view.updatedAt, terminal);
+      this.run(
+        "INSERT INTO children VALUES (?,?,?,?,?,?,?,?)",
+        view.runId,
+        child.index,
+        child.agent,
+        source,
+        filters.get(child.index) ?? "",
+        digests.get(child.index) ?? null,
+        boundary.entry,
+        boundary.endedAt,
+      );
+    }
+  }
+  info(pending: number, projectionErrors = 0): HistoryVersion {
+    const sources = this.require(
+      "SELECT COUNT(*) AS total,SUM(state IN ('pending','indexing')) AS pending,SUM(state IN ('degraded','missing','error')) AS errors FROM sources WHERE id IN (SELECT source_id FROM children)",
+    );
+    const indexedAtValue = Number(
+      text(this.require("SELECT value FROM meta WHERE key='indexedAt'"), "value"),
+    );
+    const indexedAt = indexedAtValue === 0 ? null : indexedAtValue;
+    const errors = Number(sources.errors ?? 0) + projectionErrors;
+    const remaining = pending + Number(sources.pending ?? 0);
+    const freshness: HistoryFreshness = {
+      authoritative: false,
+      state: freshnessState(remaining, errors),
+      pending: remaining,
+      errors,
+      indexedAt,
+    };
+    return {
+      version: Number(text(this.require("SELECT value FROM meta WHERE key='version'"), "value")),
+      indexedAt,
+      freshness,
+    };
+  }
+  status(pending: number): HistoryIndexStatus {
+    return {
+      ...this.info(pending),
+      databaseFile: this.file,
+      physicalSources: number(this.require("SELECT COUNT(*) AS count FROM sources"), "count"),
+      publishedEntries: number(
+        this.require("SELECT COUNT(*) AS count FROM entries WHERE published=1"),
+        "count",
+      ),
+      operations: this.operations,
+    };
+  }
+  entry(row: EntryRow): HistoryEntry {
+    return {
+      id: row.id,
+      nativeId: row.native_id,
+      parentId: row.parent_id,
+      sequence: row.start,
+      timestamp: row.timestamp,
+      type: row.type,
+      ref: {
+        sourceId: row.source_id,
+        generation: row.generation,
+        start: row.start,
+        end: row.end,
+        digest: row.digest,
+      },
+      entry: parseObject(row.preview),
+    };
+  }
+  /** A separate SQLite transaction serializes incremental staging without blocking browse queries.
+   * SQLite releases it on process death; no PID lease, expiry, or stale-file deletion is needed. */
+  beginIngest(): void {
+    if (!this.ingestLock) {
+      this.ingestLock = openHistoryDatabase(`${this.file}.ingest.sqlite`);
+      this.ingestLock.exec("PRAGMA busy_timeout=0");
+    }
+    try {
+      this.ingestLock.exec("BEGIN IMMEDIATE");
+    } catch (error) {
+      if (/locked|busy/i.test(errorMessage(error))) {
+        throw new HistoryIndexError("INDEX_BUSY", "Another worker is indexing this generation.");
+      }
+      throw error;
+    }
+  }
+  endIngest(): void {
+    if (this.ingestLock?.isTransaction === true) {
+      this.ingestLock.exec("ROLLBACK");
+    }
+  }
+  close(): void {
+    this.ingestLock?.close();
+    this.db.close();
+  }
 }
-export interface EntryRow {
-	rowid: number; source_id: string; generation: number; id: string; native_id: string | null;
-	parent_id: string | null; start: number; end: number; digest: string; timestamp: number | null;
-	type: string; preview: string; published: number; role: string | null; assistant_text: number; visible_id: string | null; human_id: string | null;
-	configuration_model: string | null; configuration_thinking: string | null;
+function terminalBoundary(
+  child: HistoryRunRow["children"][number],
+  updatedAt: number,
+  terminal: boolean,
+): { readonly entry: string | null; readonly endedAt: number | null } {
+  if (!terminal) {
+    return { entry: null, endedAt: null };
+  }
+  return {
+    entry: child.result?.terminalEntryId ?? null,
+    endedAt: hasText(child.result?.terminalEntryId) ? null : updatedAt,
+  };
 }
-export class HistoryStore {
-	readonly db: DatabaseSync;
-	readonly generation: string;
-	readonly file: string;
-	readonly owner: string;
-	readonly operations = { sourceChecks: 0, sourceOpens: 0, sourceBytesRead: 0, runProjections: 0, queries: 0 };
-	private ingestLock?: DatabaseSync;
-	private outputDigests = new Map<string, { stamp: string; digest: string }>();
-	constructor(agentDir: string, owner: string) {
-		this.owner = owner;
-		const directory = historyDirectory(agentDir);
-		const manifest = path.join(directory, `${hash(owner)}.json`);
-		let name: string | undefined;
-		try {
-			const saved = JSON.parse(fs.readFileSync(manifest, "utf8"));
-			if (typeof saved.file === "string" && /^[a-f0-9-]+\.sqlite$/.test(saved.file)) name = saved.file;
-		} catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT" && !(error instanceof SyntaxError)) throw error; }
-		let db: DatabaseSync | undefined;
-		if (name) {
-			try {
-				const file = path.join(directory, name);
-				if (!fs.existsSync(file) || fs.lstatSync(file).isSymbolicLink()) throw new HistoryIndexError("CORRUPT", "Invalid index generation.");
-				db = openHistoryDatabase(file);
-				if (db.prepare("PRAGMA user_version").get()?.user_version !== 5) throw new HistoryIndexError("CORRUPT", "Invalid index schema.");
-				db.prepare("SELECT value FROM meta WHERE key='generation'").get();
-			} catch (error) {
-				db?.close(); db = undefined;
-				if (!isCorruption(error)) throw error;
-				name = undefined;
-			}
-		}
-		if (!name) {
-			name = `${randomUUID()}.sqlite`;
-			db = openHistoryDatabase(path.join(directory, name));
-			this.schema(db);
-			const temporary = `${manifest}.${process.pid}.${randomUUID()}`;
-			fs.writeFileSync(temporary, JSON.stringify({ file: name }), { mode: 0o600 });
-			fs.renameSync(temporary, manifest);
-			// Never rename/unlink an open SQLite generation or separate its WAL. Old corrupt
-			// generations remain private for diagnosis; the manifest selects the new projection.
-		}
-		this.db = db!; this.file = path.join(directory, name!);
-		fs.chmodSync(this.file, 0o600);
-		for (const suffix of ["-wal", "-shm"]) if (fs.existsSync(this.file + suffix)) fs.chmodSync(this.file + suffix, 0o600);
-		this.generation = String(this.get("SELECT value FROM meta WHERE key='generation'")!.value);
-		this.db.exec("CREATE TEMP TABLE pending_text(field TEXT, position INTEGER, end_position INTEGER, text TEXT)");
-	}
-	private schema(db: DatabaseSync): void {
-		db.exec(`
-			CREATE TABLE meta(key TEXT PRIMARY KEY,value TEXT NOT NULL);
-			INSERT INTO meta VALUES ('generation','${randomUUID()}'),('version','0'),('indexedAt','0');
-			CREATE TABLE runs(id TEXT PRIMARY KEY,attention INTEGER NOT NULL,updated INTEGER NOT NULL,negative_updated INTEGER NOT NULL,state TEXT NOT NULL,filter_text TEXT NOT NULL,view TEXT NOT NULL,predecessor_id TEXT,predecessor_index INTEGER);
-			CREATE INDEX runs_predecessor ON runs(predecessor_id,predecessor_index);
-			CREATE INDEX runs_attention ON runs(attention,negative_updated,id);
-			CREATE INDEX runs_newest ON runs(negative_updated,id);
-			CREATE INDEX runs_oldest ON runs(updated,id);
-			CREATE INDEX runs_state ON runs(state,attention,negative_updated,id);
-			CREATE TABLE sources(id TEXT PRIMARY KEY,path TEXT NOT NULL UNIQUE,generation INTEGER NOT NULL DEFAULT 1,identity TEXT,stamp TEXT,session_id TEXT,header_digest TEXT,cursor INTEGER NOT NULL DEFAULT 0,prefix_digest TEXT,state TEXT NOT NULL DEFAULT 'pending',error TEXT,malformed INTEGER NOT NULL DEFAULT 0,complexity INTEGER NOT NULL DEFAULT 0,checked_at INTEGER,format_version INTEGER);
-			CREATE TABLE children(run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,child_index INTEGER NOT NULL,agent TEXT NOT NULL,source_id TEXT REFERENCES sources(id),filter_text TEXT NOT NULL,output_digest TEXT,terminal_entry_id TEXT,ended_at INTEGER,PRIMARY KEY(run_id,child_index));
-			CREATE INDEX children_source ON children(source_id);
-			CREATE INDEX children_agent ON children(agent,run_id);
-			CREATE TABLE entries(rowid INTEGER PRIMARY KEY,source_id TEXT NOT NULL REFERENCES sources(id),generation INTEGER NOT NULL,id TEXT NOT NULL,native_id TEXT,parent_id TEXT,start INTEGER NOT NULL,end INTEGER NOT NULL,digest TEXT NOT NULL,timestamp INTEGER,type TEXT NOT NULL,preview TEXT NOT NULL,published INTEGER NOT NULL DEFAULT 0,role TEXT,assistant_text INTEGER NOT NULL DEFAULT 0,visible_id TEXT,human_id TEXT,configuration_model TEXT,configuration_thinking TEXT,UNIQUE(source_id,generation,id),UNIQUE(source_id,generation,start));
-			CREATE INDEX entries_page ON entries(source_id,generation,published,start);
-			CREATE INDEX entries_time ON entries(source_id,generation,published,timestamp,start);
-			CREATE INDEX entries_human ON entries(source_id,generation,human_id,start);
-			CREATE TABLE answers(entry_rowid INTEGER NOT NULL REFERENCES entries(rowid) ON DELETE CASCADE,digest TEXT NOT NULL,item_id TEXT NOT NULL,PRIMARY KEY(entry_rowid,digest));
-			CREATE INDEX answers_digest ON answers(digest,entry_rowid);
-			CREATE TABLE tools(entry_rowid INTEGER NOT NULL REFERENCES entries(rowid) ON DELETE CASCADE,source_id TEXT NOT NULL,generation INTEGER NOT NULL,call_id TEXT NOT NULL,kind TEXT NOT NULL);
-			CREATE INDEX tools_lookup ON tools(source_id,generation,call_id,kind);
-			CREATE TABLE documents(id INTEGER PRIMARY KEY,entry_rowid INTEGER NOT NULL REFERENCES entries(rowid) ON DELETE CASCADE,field TEXT NOT NULL,text_start INTEGER NOT NULL,text_end INTEGER NOT NULL,preview TEXT NOT NULL);
-			CREATE INDEX documents_entry ON documents(entry_rowid);
-			CREATE VIRTUAL TABLE corpus USING fts5(text,content='',contentless_delete=1,tokenize='unicode61');
-			PRAGMA user_version=5;
-		`);
-	}
-	get(sql: string, ...params: SQLInputValue[]): any { return this.db.prepare(sql).get(...params); }
-	all(sql: string, ...params: SQLInputValue[]): any[] { return this.db.prepare(sql).all(...params); }
-	run(sql: string, ...params: SQLInputValue[]): ReturnType<ReturnType<DatabaseSync["prepare"]>["run"]> { return this.db.prepare(sql).run(...params); }
-	deleteDocuments(sourceId: string, unpublishedOnly = false): void {
-		const where = `entry_rowid IN (SELECT rowid FROM entries WHERE source_id=?${unpublishedOnly ? " AND published=0" : ""})`;
-		this.run(`DELETE FROM corpus WHERE rowid IN (SELECT id FROM documents WHERE ${where})`, sourceId);
-		this.run(`DELETE FROM documents WHERE ${where}`, sourceId);
-	}
-	transaction<T>(work: () => T): T { return historyTransaction(this.db, work); }
-	bump(): void { this.run("UPDATE meta SET value=CAST(value AS INTEGER)+1 WHERE key='version'"); this.run("UPDATE meta SET value=? WHERE key='indexedAt'", String(Date.now())); }
-	source(id: string): SourceRow | undefined { return this.get("SELECT * FROM sources WHERE id=?", id); }
-	resetSource(id: string, state = "pending", error: string | null = null): void {
-		this.transaction(() => {
-			this.deleteDocuments(id);
-			this.run("DELETE FROM entries WHERE source_id=?", id);
-			this.run("UPDATE sources SET generation=generation+1,identity=NULL,stamp=NULL,session_id=NULL,header_digest=NULL,format_version=NULL,cursor=0,prefix_digest=NULL,state=?,error=?,malformed=0,complexity=0,checked_at=? WHERE id=?", state, error, Date.now(), id);
-			this.bump();
-		});
-	}
-	clearUnpublished(id: string): void {
-		this.transaction(() => {
-			this.deleteDocuments(id, true);
-			this.run("DELETE FROM entries WHERE source_id=? AND published=0", id);
-		});
-	}
-	private outputDigest(result: HistoryRunRow["children"][number]["result"]): string | null {
-		if (!result) return null;
-		if (!result.fullOutputPath) return typeof result.finalOutput === "string" && result.finalOutput.length !== 8192 && !result.truncation?.truncated ? exactTextDigest(result.finalOutput) : null;
-		try {
-			const stat = fs.statSync(result.fullOutputPath, { bigint: true });
-			if (!stat.isFile() || stat.size > 16n * 1024n * 1024n) return null;
-			const stamp = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-			const cached = this.outputDigests.get(result.fullOutputPath);
-			if (cached?.stamp === stamp) return cached.digest;
-			const text = readSavedOutput(result.fullOutputPath);
-			const digest = exactTextDigest(text);
-			this.outputDigests.set(result.fullOutputPath, { stamp, digest });
-			return digest;
-		} catch { return null; }
-	}
-	putView(view: HistoryRunRow, full: HistoryRunRow = view): void {
-		const attention = view.attention.includes("awaiting_input") ? 0 : view.attention.some((reason) => reason !== "unreviewed") ? 1 : view.state === "live" ? 2 : view.attention.length ? 3 : 4;
-		const json = JSON.stringify(view), filters = new Map(full.children.map((child) => [child.index, safeText(`${child.agent} ${child.label ?? ""} ${child.task ?? full.task}`, Infinity).toLowerCase()]));
-		const filterText = safeText(`${full.task} ${[...filters.values()].join(" ")}`, Infinity).toLowerCase();
-		const digests = new Map(full.children.map((child) => [child.index, this.outputDigest(child.result)]));
-		const saved = this.get("SELECT view,filter_text FROM runs WHERE id=?", view.runId);
-		if (saved?.view === json && saved.filter_text === filterText && this.all("SELECT child_index,output_digest FROM children WHERE run_id=?", view.runId).every((child) => child.output_digest === digests.get(child.child_index))) return;
-		this.transaction(() => {
-			this.run("INSERT INTO runs VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET attention=excluded.attention,updated=excluded.updated,negative_updated=excluded.negative_updated,state=excluded.state,filter_text=excluded.filter_text,view=excluded.view,predecessor_id=excluded.predecessor_id,predecessor_index=excluded.predecessor_index", view.runId, attention, view.updatedAt, -view.updatedAt, view.state, filterText, json, view.predecessorRunId ?? null, view.predecessorIndex ?? 0);
-			this.run("DELETE FROM children WHERE run_id=?", view.runId);
-			for (const child of view.children) {
-				let source: string | null = null;
-				if (child.sessionFile) {
-					const file = path.resolve(child.sessionFile); source = hash(file);
-					this.run("INSERT INTO sources(id,path) VALUES (?,?) ON CONFLICT(id) DO NOTHING", source, file);
-				}
-				const terminal = child.state !== "live" && child.state !== "unknown";
-				this.run("INSERT INTO children VALUES (?,?,?,?,?,?,?,?)", view.runId, child.index, child.agent, source, filters.get(child.index) ?? "", digests.get(child.index) ?? null,
-					terminal ? child.result?.terminalEntryId ?? null : null, terminal && !child.result?.terminalEntryId ? view.updatedAt : null);
-			}
-			this.bump();
-		});
-	}
-	info(pending: number): HistoryVersion {
-		const sources = this.get("SELECT COUNT(*) AS total,SUM(state IN ('pending','indexing')) AS pending,SUM(state IN ('degraded','missing','error')) AS errors FROM sources WHERE id IN (SELECT source_id FROM children)");
-		const indexedAt = Number(this.get("SELECT value FROM meta WHERE key='indexedAt'").value) || null;
-		const errors = Number(sources.errors ?? 0);
-		const remaining = pending + Number(sources.pending ?? 0);
-		const freshness: HistoryFreshness = { authoritative: false, state: remaining ? "catching-up" : errors ? "degraded" : "current", pending: remaining, errors, indexedAt };
-		return { version: Number(this.get("SELECT value FROM meta WHERE key='version'").value), indexedAt, freshness };
-	}
-	entry(row: EntryRow): HistoryEntry {
-		return { id: row.id, nativeId: row.native_id, parentId: row.parent_id, sequence: row.start, timestamp: row.timestamp, type: row.type,
-			ref: { sourceId: row.source_id, generation: row.generation, start: row.start, end: row.end, digest: row.digest }, entry: JSON.parse(row.preview) };
-	}
-	/** A separate SQLite transaction serializes incremental staging without blocking browse queries.
-	 * SQLite releases it on process death; no PID lease, expiry, or stale-file deletion is needed. */
-	beginIngest(): void {
-		if (!this.ingestLock) {
-			this.ingestLock = openHistoryDatabase(`${this.file}.ingest.sqlite`);
-			this.ingestLock.exec("PRAGMA busy_timeout=0");
-		}
-		try { this.ingestLock.exec("BEGIN IMMEDIATE"); }
-		catch (error) {
-			if (/locked|busy/i.test(String((error as Error).message))) throw new HistoryIndexError("INDEX_BUSY", "Another worker is indexing this generation.");
-			throw error;
-		}
-	}
-	endIngest(): void { if (this.ingestLock?.isTransaction) this.ingestLock.exec("ROLLBACK"); }
-	close(): void { this.ingestLock?.close(); this.db.close(); }
+function attentionRank(view: HistoryRunRow): number {
+  if (view.attention.includes("awaiting_input")) {
+    return 0;
+  }
+  if (view.attention.some((reason) => reason !== "unreviewed")) {
+    return 1;
+  }
+  if (view.state === "live") {
+    return 2;
+  }
+  return view.attention.length > 0 ? 3 : 4;
 }
-function isCorruption(error: unknown): boolean {
-	return error instanceof HistoryIndexError && error.code === "CORRUPT" || /malformed|not a database|no such table|corrupt/i.test(String((error as Error).message));
+function freshnessState(pending: number, errors: number): HistoryFreshness["state"] {
+  if (pending > 0) {
+    return "catching-up";
+  }
+  return errors > 0 ? "degraded" : "current";
 }