@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/history/query-scope.js

@@ -1,190 +0,0 @@
-import { Type, Check } from "../shared/native-typebox.js";
-import { HistoryIndexError, } from "./types.js";
-import { hash, integer, hasText } from "./text.js";
-import { number, nullableText, nullableNumber, text, } from "./rows.js";
-import { parseObject } from "./values.js";
-const cursorSchema = Type.Object({
-    generation: Type.String(),
-    owner: Type.String(),
-    version: Type.Number(),
-    query: Type.String(),
-    keys: Type.Array(Type.Union([Type.Number(), Type.String()]), { maxItems: 8 }),
-    offset: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
-});
-function configurationValues(facts, leaf, strict) {
-    const count = number(facts, "count");
-    if (count === 0 && hasText(leaf) && strict) {
-        throw new HistoryIndexError("BOUNDARY_UNAVAILABLE", "Selected configuration leaf is not available in the indexed generation.");
-    }
-    if (count > 0 && number(facts, "rooted") === 0) {
-        if (!strict) {
-            return {};
-        }
-        throw new HistoryIndexError("MALFORMED_ANCESTRY", "Selected native configuration has cyclic ancestry.");
-    }
-    const model = nullableText(facts, "model");
-    const thinking = nullableText(facts, "thinking");
-    return {
-        ...(model === null
-            ? {}
-            : { model, modelRecordedAt: nullableNumber(facts, "recorded_at") ?? undefined }),
-        ...(thinking === null ? {} : { thinking }),
-    };
-}
-function configurationKey(source, input, strict) {
-    const terminal = hasText(input.terminalEntryId);
-    return JSON.stringify([
-        source.id,
-        source.generation,
-        source.cursor,
-        source.stamp,
-        terminal ? input.terminalEntryId : null,
-        terminal ? null : (input.endedAt ?? null),
-        input.leaf === undefined ? null : [typeof input.leaf, input.leaf],
-        strict,
-    ]);
-}
-export class QueryScope {
-    store;
-    info;
-    configurations = new Map();
-    constructor(store, info) {
-        this.store = store;
-        this.info = info;
-    }
-    sourcesRemoved() {
-        this.configurations.clear();
-    }
-    key(parts) {
-        return hash(JSON.stringify(parts));
-    }
-    cursor(query, keys, offset) {
-        return Buffer.from(JSON.stringify({
-            generation: this.store.generation,
-            owner: this.store.owner,
-            version: this.info().version,
-            query,
-            keys,
-            offset,
-        })).toString("base64url");
-    }
-    parseCursor(value, query) {
-        if (value === undefined) {
-            return;
-        }
-        let cursor;
-        try {
-            if (value.length > 4096) {
-                throw new Error("Cursor exceeds budget.");
-            }
-            const parsed = parseObject(Buffer.from(value, "base64url").toString("utf8"));
-            if (!Check(cursorSchema, parsed)) {
-                throw new Error("Invalid cursor fields.");
-            }
-            cursor = parsed;
-        }
-        catch {
-            throw new HistoryIndexError("INVALID_CURSOR", "Invalid history cursor.");
-        }
-        if (cursor.generation !== this.store.generation ||
-            cursor.owner !== this.store.owner ||
-            cursor.query !== query ||
-            cursor.version !== this.info().version) {
-            throw new HistoryIndexError("STALE_CURSOR", "History changed or this cursor belongs to a different query/source; restart paging.");
-        }
-        return cursor;
-    }
-    child(runId, index) {
-        integer(index, 0);
-        const child = this.store.get("SELECT * FROM children WHERE run_id=? AND child_index=?", runId, index);
-        if (!child) {
-            throw new HistoryIndexError("OWNERSHIP", "Run/child is not in the current owner's admitted handles.");
-        }
-        const sourceId = nullableText(child, "source_id");
-        return {
-            source: sourceId === null ? undefined : this.store.source(sourceId),
-            agent: text(child, "agent"),
-        };
-    }
-    boundary(source, input, alias = "") {
-        const column = alias.length > 0 ? `${alias}.` : "";
-        const clauses = [`${column}source_id=?`, `${column}generation=?`, `${column}published=1`];
-        const params = [source.id, source.generation];
-        let terminalSequence;
-        if (input.terminalEntryId !== undefined && input.terminalEntryId.length > 0) {
-            const terminal = this.store.get("SELECT start FROM entries WHERE source_id=? AND generation=? AND id=? AND published=1", source.id, source.generation, input.terminalEntryId);
-            if (!terminal) {
-                throw new HistoryIndexError("BOUNDARY_UNAVAILABLE", "Saved terminal entry is not available in the current indexed generation.");
-            }
-            terminalSequence = number(terminal, "start");
-            clauses.push(`${column}start<=?`);
-            params.push(terminalSequence);
-        }
-        else if (input.endedAt !== undefined) {
-            clauses.push(`${column}timestamp<=?`);
-            params.push(integer(input.endedAt, 0));
-        }
-        return { clauses, params, terminalSequence };
-    }
-    configurationFacts(source, input) {
-        const boundary = this.boundary(source, input);
-        const latest = this.store.get(`SELECT id FROM entries WHERE ${boundary.clauses.join(" AND ")} ORDER BY start DESC LIMIT 1`, ...boundary.params);
-        const leaf = input.leaf ?? (latest ? text(latest, "id") : undefined);
-        if (leaf === undefined || leaf.length === 0) {
-            return;
-        }
-        // Resolve each child's parent by its indexed ID, not a transcript rescan at every step.
-        const ancestry = `WITH RECURSIVE eligible AS (SELECT rowid,id,parent_id,start,timestamp,configuration_model,configuration_thinking FROM entries WHERE ${boundary.clauses.join(" AND ")}), branch AS (SELECT * FROM eligible WHERE id=? UNION SELECT parent.* FROM branch child CROSS JOIN eligible parent WHERE parent.id=child.parent_id)`;
-        return this.store.require(`${ancestry} SELECT
-      (SELECT COUNT(*) FROM branch) AS count,
-      EXISTS(SELECT 1 FROM branch child WHERE parent_id IS NULL OR NOT EXISTS(SELECT 1 FROM eligible parent WHERE parent.id=child.parent_id)) AS rooted,
-      (SELECT configuration_model FROM branch WHERE configuration_model IS NOT NULL ORDER BY start DESC LIMIT 1) AS model,
-      (SELECT timestamp FROM branch WHERE configuration_model IS NOT NULL ORDER BY start DESC LIMIT 1) AS recorded_at,
-      (SELECT configuration_thinking FROM branch WHERE configuration_thinking IS NOT NULL ORDER BY start DESC LIMIT 1) AS thinking`, ...boundary.params, leaf);
-    }
-    configuration(source, input, strict = true) {
-        if (input.leaf === null) {
-            return {};
-        }
-        try {
-            // Validate boundaries before reuse. Only committed source changes invalidate ancestry.
-            this.boundary(source, input);
-            const key = configurationKey(source, input, strict);
-            const cached = this.configurations.get(key);
-            if (cached) {
-                return { ...cached };
-            }
-            const facts = this.configurationFacts(source, input);
-            if (!facts) {
-                return {};
-            }
-            const configuration = configurationValues(facts, input.leaf, strict);
-            this.cacheConfiguration(key, configuration);
-            return { ...configuration };
-        }
-        catch (error) {
-            if (!strict && error instanceof HistoryIndexError && error.code === "BOUNDARY_UNAVAILABLE") {
-                return {};
-            }
-            throw error;
-        }
-    }
-    cacheConfiguration(key, configuration) {
-        if (this.configurations.size >= 128) {
-            const oldest = this.configurations.keys().next().value;
-            if (oldest !== undefined) {
-                this.configurations.delete(oldest);
-            }
-        }
-        this.configurations.set(key, configuration);
-    }
-    finalResultId(input, digest, preferredRange) {
-        const { source } = this.child(input.runId, input.index);
-        if (!source) {
-            return;
-        }
-        const boundary = this.boundary(source, input, "e");
-        const row = this.store.get(`SELECT a.item_id FROM answers a JOIN entries e ON e.rowid=a.entry_rowid WHERE a.digest=? AND ${boundary.clauses.join(" AND ")} ORDER BY ${preferredRange ? "(e.start BETWEEN ? AND ?) DESC," : ""}e.start DESC LIMIT 1`, digest, ...boundary.params, ...(preferredRange ?? []));
-        return row ? text(row, "item_id") : undefined;
-    }
-}

package/dist/history/rows.js

@@ -1,77 +0,0 @@
-import { isRecord } from "../shared/unknown.js";
-import { HistoryIndexError } from "./types.js";
-export function indexRow(input) {
-    if (!isRecord(input)) {
-        throw new HistoryIndexError("CORRUPT", "Invalid index row.");
-    }
-    const row = {};
-    for (const [key, value] of Object.entries(input)) {
-        if (value !== null && typeof value !== "string" && typeof value !== "number") {
-            throw new HistoryIndexError("CORRUPT", `Unsupported index column ${key}.`);
-        }
-        row[key] = value;
-    }
-    return row;
-}
-export function text(row, key) {
-    const value = row[key];
-    if (typeof value !== "string") {
-        throw new HistoryIndexError("CORRUPT", `Invalid index text column ${key}.`);
-    }
-    return value;
-}
-export function number(row, key) {
-    const value = row[key];
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw new HistoryIndexError("CORRUPT", `Invalid index numeric column ${key}.`);
-    }
-    return value;
-}
-export function nullableText(row, key) {
-    return row[key] === null ? null : text(row, key);
-}
-export function nullableNumber(row, key) {
-    return row[key] === null ? null : number(row, key);
-}
-export function sourceRow(row) {
-    return {
-        id: text(row, "id"),
-        path: text(row, "path"),
-        generation: number(row, "generation"),
-        identity: nullableText(row, "identity"),
-        stamp: nullableText(row, "stamp"),
-        session_id: nullableText(row, "session_id"),
-        header_digest: nullableText(row, "header_digest"),
-        cursor: number(row, "cursor"),
-        prefix_digest: nullableText(row, "prefix_digest"),
-        state: text(row, "state"),
-        error: nullableText(row, "error"),
-        malformed: number(row, "malformed"),
-        complexity: number(row, "complexity"),
-        checked_at: nullableNumber(row, "checked_at"),
-        format_version: nullableNumber(row, "format_version"),
-    };
-}
-export function entryRow(row) {
-    return {
-        rowid: number(row, "rowid"),
-        source_id: text(row, "source_id"),
-        generation: number(row, "generation"),
-        id: text(row, "id"),
-        native_id: nullableText(row, "native_id"),
-        parent_id: nullableText(row, "parent_id"),
-        start: number(row, "start"),
-        end: number(row, "end"),
-        digest: text(row, "digest"),
-        timestamp: nullableNumber(row, "timestamp"),
-        type: text(row, "type"),
-        preview: text(row, "preview"),
-        published: number(row, "published"),
-        role: nullableText(row, "role"),
-        assistant_text: number(row, "assistant_text"),
-        visible_id: nullableText(row, "visible_id"),
-        human_id: nullableText(row, "human_id"),
-        configuration_model: nullableText(row, "configuration_model"),
-        configuration_thinking: nullableText(row, "configuration_thinking"),
-    };
-}

package/dist/history/run-projection.js

@@ -1,136 +0,0 @@
-import { ownedRunView } from "../runs/shared/run-records.js";
-import { acceptanceHumanAction } from "../runs/shared/acceptance-evaluation.js";
-import { getRunMetadataDir, listRunQuestions, summarizeSupervisorQuestion, } from "../runs/shared/supervisor-questions.js";
-import { safeText } from "./text.js";
-function compactResult(result) {
-    if (!result) {
-        return;
-    }
-    return {
-        agent: result.agent,
-        task: safeText(result.task),
-        exitCode: result.exitCode,
-        usage: {
-            input: result.usage.input,
-            output: result.usage.output,
-            cacheRead: result.usage.cacheRead,
-            cacheWrite: result.usage.cacheWrite,
-            cost: result.usage.cost,
-            turns: result.usage.turns,
-        },
-        finalOutput: safeText(result.finalOutput, 1024),
-        error: result.error === undefined ? undefined : safeText(result.error),
-        sessionFile: result.sessionFile,
-        terminalEntryId: result.terminalEntryId,
-        terminalLeafId: result.terminalLeafId,
-        detached: result.detached,
-        interrupted: result.interrupted,
-        timedOut: result.timedOut,
-        nativeSessionId: result.nativeSessionId,
-        accounting: result.accounting,
-        agentProcessExit: result.agentProcessExit,
-        model: result.model,
-        fullOutputPath: result.fullOutputPath,
-    };
-}
-function compactActivity(activity) {
-    if (!activity) {
-        return;
-    }
-    return {
-        status: activity.status,
-        currentTool: activity.currentTool,
-        currentToolArgs: activity.currentToolArgs === undefined ? undefined : safeText(activity.currentToolArgs, 256),
-        currentPath: activity.currentPath,
-        streamingText: activity.streamingText === undefined
-            ? undefined
-            : safeText(activity.streamingText.slice(-2048), 2048),
-        lastActivityAt: activity.lastActivityAt,
-        recentOutput: activity.recentOutput?.slice(-4).map((line) => safeText(line, 256)),
-    };
-}
-function compactChild(child) {
-    return {
-        agent: child.agent,
-        index: child.index,
-        workflowNodeId: child.workflowNodeId,
-        sessionFile: child.sessionFile,
-        task: child.task === undefined ? undefined : safeText(child.task),
-        label: child.label === undefined ? undefined : safeText(child.label, 256),
-        state: child.state,
-        configuration: child.configuration,
-        missingSession: child.missingSession,
-        identityUnavailable: child.identityUnavailable,
-        modelSelection: child.modelSelection,
-        savedConfiguration: child.launch && {
-            model: child.launch.model,
-            thinking: child.launch.thinking,
-            modelRecordedAt: child.launch.modelRecordedAt,
-        },
-        humanAction: child.result?.acceptance && safeText(acceptanceHumanAction(child.result.acceptance), 2048),
-        acceptanceStatus: child.result?.acceptance?.status,
-        activity: compactActivity(child.activity),
-        result: compactResult(child.result),
-    };
-}
-function compactQuestion(question) {
-    const summary = summarizeSupervisorQuestion(question);
-    return {
-        ...summary,
-        message: safeText(question.message, 2048),
-        answer: summary.answer && {
-            ...summary.answer,
-            message: safeText(question.answer?.message, 2048),
-        },
-    };
-}
-export function unknownRun(run, diagnosis = "Run summary is awaiting background canonical projection.") {
-    return {
-        ...run,
-        state: "unknown",
-        updatedAt: run.startedAt,
-        attention: ["unknown"],
-        canInterrupt: false,
-        continuations: [],
-        children: run.children.map((child) => ({
-            ...child,
-            state: "unknown",
-            configuration: "legacy-partial",
-        })),
-        diagnosis,
-    };
-}
-export function compactView(view) {
-    return {
-        ...view,
-        task: safeText(view.task, 2048),
-        error: view.error === undefined ? undefined : safeText(view.error),
-        diagnosis: view.diagnosis === undefined ? undefined : safeText(view.diagnosis),
-        recoveryError: view.recoveryError === undefined ? undefined : safeText(view.recoveryError),
-        review: view.review && {
-            ...view.review,
-            message: view.review.message === undefined ? undefined : safeText(view.review.message),
-        },
-        continuations: [],
-        questions: view.questions?.map(compactQuestion),
-        children: view.children.map(compactChild),
-        summary: safeText(view.children
-            .map((child) => child.result?.finalOutput ?? child.result?.error ?? "")
-            .filter((text) => text.length > 0)
-            .join(" | "), 1024),
-    };
-}
-/** Canonical owner/filesystem projection. Native transcript presence never establishes completion. */
-export function projectRun(run, ownerSessionId, runs, foreground) {
-    const state = { ownedRuns: runs, foregroundRuns: foreground };
-    const questions = listRunQuestions(getRunMetadataDir(run.runId), ownerSessionId).filter((question) => ["awaiting_input", "answer_pending"].includes(question.state));
-    return {
-        ...ownedRunView(run, state, {
-            pendingInput: questions.length > 0,
-            includeContinuations: false,
-            readConfiguration: false,
-            reconcile: false,
-        }),
-        questions,
-    };
-}

package/dist/history/run-queries.js

@@ -1,153 +0,0 @@
-import { HistoryIndexError, } from "./types.js";
-import { integer, pageLimit, hasText } from "./text.js";
-import { number, text } from "./rows.js";
-import { parseRunRow } from "./wire-models.js";
-function validate(options) {
-    if (options.state !== undefined &&
-        !["live", "completed", "paused", "blocked", "failed", "unknown"].includes(options.state)) {
-        throw new HistoryIndexError("INVALID", "Unsupported run state.");
-    }
-    validateFilters(options);
-}
-function validateFilters(options) {
-    if ((options.text?.length ?? 0) > 256 ||
-        (options.agent?.length ?? 0) > 256 ||
-        (options.latestTasksOnly !== undefined && typeof options.latestTasksOnly !== "boolean")) {
-        throw new HistoryIndexError("INVALID", "Invalid run filter.");
-    }
-}
-function queryKey(scope, options, sort) {
-    return scope.key([
-        "runs",
-        sort,
-        options.agent ?? null,
-        options.state ?? null,
-        options.text?.toLowerCase() ?? null,
-        options.latestTasksOnly ?? false,
-    ]);
-}
-function filters(options) {
-    const clauses = [];
-    const params = [];
-    const childClauses = [];
-    const childParams = [];
-    if (hasText(options.agent)) {
-        childClauses.push("c.agent=?");
-        childParams.push(options.agent);
-    }
-    if (hasText(options.text)) {
-        childClauses.push("instr(c.filter_text,?)>0");
-        childParams.push(options.text.toLowerCase());
-    }
-    if (options.latestTasksOnly === true) {
-        childClauses.push("NOT EXISTS(SELECT 1 FROM runs successor WHERE successor.predecessor_id=c.run_id AND successor.predecessor_index=c.child_index)");
-    }
-    const childWhere = childClauses.length > 0 ? ` AND ${childClauses.join(" AND ")}` : "";
-    if (childWhere.length > 0) {
-        clauses.push(`EXISTS(SELECT 1 FROM children c WHERE c.run_id=r.id${childWhere})`);
-        params.push(...childParams);
-    }
-    if (hasText(options.state)) {
-        clauses.push("r.state=?");
-        params.push(options.state);
-    }
-    return { clauses, params, childWhere, childParams };
-}
-function columns(sort) {
-    if (sort === "attention") {
-        return ["attention", "negative_updated", "id"];
-    }
-    return [sort === "newest" ? "negative_updated" : "updated", "id"];
-}
-function runSort(value) {
-    const sort = value ?? "attention";
-    if (!["attention", "newest", "oldest"].includes(sort)) {
-        throw new HistoryIndexError("INVALID", "Unsupported run sort.");
-    }
-    return sort;
-}
-function seek(filter, cursor, order) {
-    if (!cursor) {
-        return filter;
-    }
-    if (cursor.keys.length !== order.length) {
-        throw new HistoryIndexError("INVALID_CURSOR", "Invalid run seek tuple.");
-    }
-    return {
-        ...filter,
-        clauses: [
-            ...filter.clauses,
-            `(${order.map((column) => `r.${column}`).join(",")}) > (${order.map(() => "?").join(",")})`,
-        ],
-        params: [...filter.params, ...cursor.keys],
-    };
-}
-export class RunQueries {
-    scope;
-    constructor(scope) {
-        this.scope = scope;
-    }
-    view(row, filter) {
-        const value = JSON.parse(text(row, "view"));
-        const view = parseRunRow(value);
-        const matchedChildIndexes = filter.childWhere.length > 0
-            ? this.scope.store
-                .all(`SELECT child_index FROM children c WHERE c.run_id=?${filter.childWhere} ORDER BY child_index`, view.runId, ...filter.childParams)
-                .map((child) => number(child, "child_index"))
-            : view.matchedChildIndexes;
-        return {
-            ...view,
-            ...(matchedChildIndexes === undefined ? {} : { matchedChildIndexes }),
-            children: view.children.map((child) => {
-                const { source } = this.scope.child(view.runId, child.index);
-                if (!source) {
-                    return child;
-                }
-                const boundary = child.state === "live"
-                    ? {}
-                    : {
-                        terminalEntryId: child.result?.terminalEntryId,
-                        endedAt: (child.result?.terminalEntryId?.length ?? 0) > 0 ? undefined : view.updatedAt,
-                        leaf: child.result?.terminalLeafId,
-                    };
-                return Object.assign({}, child, {
-                    nativeConfiguration: this.scope.configuration(source, boundary, false),
-                });
-            }),
-        };
-    }
-    nextPage(query, order, page, position) {
-        const last = page.at(-1);
-        return last
-            ? {
-                nextOffset: position + page.length,
-                nextCursor: this.scope.cursor(query, order.map((column) => (column === "id" ? text(last, column) : number(last, column))), position + page.length),
-            }
-            : {};
-    }
-    list(options) {
-        validate(options);
-        const limit = pageLimit(options.limit, 20);
-        const offset = integer(options.offset, 0);
-        const sort = runSort(options.sort);
-        const query = queryKey(this.scope, options, sort);
-        const cursor = this.scope.parseCursor(options.cursor, query);
-        if (cursor && options.offset !== undefined) {
-            throw new HistoryIndexError("INVALID", "Use cursor or offset, not both.");
-        }
-        const filter = filters(options);
-        const total = number(this.scope.store.require(`SELECT COUNT(*) AS total FROM runs r ${filter.clauses.length > 0 ? `WHERE ${filter.clauses.join(" AND ")}` : ""}`, ...filter.params), "total");
-        const order = columns(sort);
-        const selected = seek(filter, cursor, order);
-        const rows = this.scope.store.all(`SELECT * FROM runs r ${selected.clauses.length > 0 ? `WHERE ${selected.clauses.join(" AND ")}` : ""} ORDER BY ${order.map((column) => `r.${column}`).join(",")} LIMIT ? OFFSET ?`, ...selected.params, limit + 1, cursor ? 0 : offset);
-        const page = rows.slice(0, limit);
-        const position = cursor?.offset ?? offset;
-        return {
-            rows: page.map((row) => this.view(row, filter)),
-            total,
-            offset: position,
-            ...this.scope.info(),
-            ...this.nextPage(query, order, rows.length > limit ? page : [], position),
-        };
-    }
-}

package/dist/history/schema.js

@@ -1,31 +0,0 @@
-import { randomUUID } from "node:crypto";
-export const HISTORY_SCHEMA_VERSION = 5;
-/** One schema version owns the row, FTS and cursor publication contracts together. */
-export function createHistorySchema(db) {
-    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=${HISTORY_SCHEMA_VERSION};
-  `);
-}