@plico-ai/runtime 0.0.0-reserved.0 → 0.1.0

package/dist/storage/sqlite/owner-lock.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+import { rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { createDatabase } from "./driver.js";
+let current;
+function lockPath(token) {
+    return join(tmpdir(), `plico-run-owner-${token}.sqlite`);
+}
+export function acquireOwner() {
+    if (current)
+        return current;
+    const token = randomUUID();
+    const path = lockPath(token);
+    const database = createDatabase(path);
+    // SQLite releases this process-owned lock on exit, even when a PID is reused.
+    database.exec("CREATE TABLE owner_lock (id INTEGER); BEGIN EXCLUSIVE;");
+    current = { token, path, database };
+    process.once("exit", () => {
+        try {
+            database.close();
+            rmSync(path, { force: true });
+        }
+        catch {
+            /* OS cleanup may happen later. */
+        }
+    });
+    return current;
+}
+export function ownerIsAlive(token, path) {
+    if (current?.token === token)
+        return true;
+    if (!/^[a-f0-9-]{36}$/.test(token) || basename(path) !== `plico-run-owner-${token}.sqlite`)
+        return true;
+    try {
+        statSync(path);
+    }
+    catch (error) {
+        // ENOENT means the owner is gone, though a temp-folder cleaner could remove a live lock file.
+        return error.code !== "ENOENT";
+    }
+    let probe;
+    try {
+        probe = createDatabase(path, { readOnly: true });
+        probe.exec("PRAGMA busy_timeout = 0; BEGIN EXCLUSIVE; ROLLBACK;");
+        return false;
+    }
+    catch {
+        // Any probe error counts as alive, so the run stays running rather than failing spuriously.
+        return true;
+    }
+    finally {
+        probe?.close();
+    }
+}

package/dist/storage/sqlite/project-thread.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { PlicoEvent } from "@plico-ai/contracts";
+/** Called inside the run event transaction so the transcript cannot lag behind its log. */
+export declare function projectThreadEvent(db: DatabaseSync, event: PlicoEvent): void;

package/dist/storage/sqlite/project-thread.js

@@ -0,0 +1,33 @@
+import { randomUUID } from "node:crypto";
+import { appendThreadEvent } from "./thread-log.js";
+import { retitleThread } from "./thread-title.js";
+/** Called inside the run event transaction so the transcript cannot lag behind its log. */
+export function projectThreadEvent(db, event) {
+    if (event.type === "run.started" && event.payload.threadId) {
+        const threadId = event.payload.threadId;
+        if (!db.prepare("SELECT 1 FROM threads WHERE thread_id = ?").get(threadId))
+            throw new Error("Unknown thread.");
+        db.prepare("INSERT OR IGNORE INTO thread_runs (run_id, thread_id) VALUES (?, ?)").run(event.runId, threadId);
+        const linked = db
+            .prepare("SELECT thread_id FROM thread_runs WHERE run_id = ?")
+            .get(event.runId);
+        if (linked.thread_id !== threadId)
+            throw new Error("Run already belongs to another thread.");
+    }
+    if (event.type !== "run.completed" || event.payload.output === undefined)
+        return;
+    const run = db.prepare("SELECT thread_id FROM thread_runs WHERE run_id = ?").get(event.runId);
+    if (!run)
+        return;
+    const message = {
+        id: randomUUID(),
+        threadId: run.thread_id,
+        role: "assistant",
+        content: event.payload.output,
+        createdAt: event.timestamp,
+        runId: event.runId,
+    };
+    const sequence = appendThreadEvent(db, run.thread_id, "message.created", { message }, event.timestamp);
+    db.prepare("INSERT INTO thread_messages (message_id, thread_id, role, content, created_at, sequence, run_id) VALUES (?, ?, 'assistant', ?, ?, ?, ?)").run(message.id, run.thread_id, message.content, event.timestamp, sequence, event.runId);
+    retitleThread(db, run.thread_id, event.timestamp);
+}

package/dist/storage/sqlite/queries.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { EvalReport, PlicoEvent, RunSummary } from "@plico-ai/contracts";
+export declare function readRunSummaries(database: DatabaseSync): RunSummary[];
+export declare function readRunSummary(database: DatabaseSync, runId: string): RunSummary | undefined;
+export declare function readEvents(database: DatabaseSync, runId: string, afterSequence: number | undefined): PlicoEvent[];
+export declare function readThreadRunEvents(database: DatabaseSync, threadId: string): PlicoEvent[];
+export declare function readThreadRunEventsThrough(database: DatabaseSync, threadId: string, runId: string): PlicoEvent[];
+export declare function persistEvalReportRecord(database: DatabaseSync, report: EvalReport): void;
+export declare function readLatestEvalReport(database: DatabaseSync): EvalReport | undefined;

package/dist/storage/sqlite/queries.js

@@ -0,0 +1,134 @@
+import { runStreamType } from "../../events.js";
+import { parseMetadata } from "../metadata.js";
+export function readRunSummaries(database) {
+    const rows = database
+        .prepare(`
+        SELECT run_id, project_root, project_name, status, started_at, ended_at, output, metadata_json
+        FROM runs
+        ORDER BY started_at DESC, run_id DESC
+      `)
+        .all();
+    return rows.map((row) => rowToRunSummary(row));
+}
+export function readRunSummary(database, runId) {
+    const row = database
+        .prepare(`
+        SELECT run_id, project_root, project_name, status, started_at, ended_at, output, metadata_json
+        FROM runs
+        WHERE run_id = ?
+      `)
+        .get(runId);
+    return row ? rowToRunSummary(row) : undefined;
+}
+export function readEvents(database, runId, afterSequence) {
+    const rows = database
+        .prepare(`
+        SELECT events.stream_id, events.sequence, events.event_id, events.schema_version,
+          events.type, events.timestamp, events.payload_json, artifact_content.content AS artifact_content
+        FROM events
+        LEFT JOIN artifact_content ON artifact_content.content_hash = json_extract(events.payload_json, '$.contentHash')
+        WHERE stream_type = ? AND stream_id = ? AND sequence > ?
+        ORDER BY sequence ASC
+      `)
+        .all(runStreamType, runId, afterSequence ?? 0);
+    return rows.map((row) => rowToEvent(row));
+}
+export function readThreadRunEvents(database, threadId) {
+    const rows = database
+        .prepare(`
+        SELECT events.stream_id, events.sequence, events.event_id, events.schema_version,
+          events.type, events.timestamp, events.payload_json, artifact_content.content AS artifact_content
+        FROM events
+        JOIN thread_runs ON thread_runs.run_id = events.stream_id
+        LEFT JOIN artifact_content ON artifact_content.content_hash = json_extract(events.payload_json, '$.contentHash')
+        WHERE events.stream_type = 'run' AND thread_runs.thread_id = ?
+        ORDER BY events.position ASC
+      `)
+        .all(threadId);
+    return rows.map((row) => rowToEvent(row));
+}
+export function readThreadRunEventsThrough(database, threadId, runId) {
+    const rows = database
+        .prepare(`
+        WITH selected_run_position AS (
+          SELECT MAX(target_events.position) AS position
+          FROM events AS target_events
+          JOIN thread_runs AS target_runs ON target_runs.run_id = target_events.stream_id
+          WHERE target_events.stream_type = 'run'
+            AND target_runs.thread_id = ?
+            AND target_events.stream_id = ?
+        )
+        SELECT events.stream_id, events.sequence, events.event_id, events.schema_version,
+          events.type, events.timestamp, events.payload_json, artifact_content.content AS artifact_content
+        FROM events
+        JOIN thread_runs ON thread_runs.run_id = events.stream_id
+        LEFT JOIN artifact_content ON artifact_content.content_hash = json_extract(events.payload_json, '$.contentHash')
+        WHERE events.stream_type = 'run' AND thread_runs.thread_id = ?
+          AND events.position <= (SELECT position FROM selected_run_position)
+        ORDER BY events.position ASC
+      `)
+        .all(threadId, runId, threadId);
+    return rows.map((row) => rowToEvent(row));
+}
+export function persistEvalReportRecord(database, report) {
+    database
+        .prepare("INSERT INTO eval_reports (evaluated_at, report_json) VALUES (?, ?)")
+        .run(report.evaluatedAt, JSON.stringify(report));
+}
+export function readLatestEvalReport(database) {
+    // Read-only stores skip schema setup, so older databases may lack this table.
+    const hasTable = database
+        .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'eval_reports'")
+        .get();
+    if (!hasTable)
+        return undefined;
+    const row = database
+        .prepare("SELECT report_json FROM eval_reports ORDER BY id DESC LIMIT 1")
+        .get();
+    if (!row)
+        return undefined;
+    // A report from another version is not readable here; the next eval run replaces it.
+    const report = JSON.parse(row.report_json);
+    return report.schemaVersion === 1 ? report : undefined;
+}
+function rowToRunSummary(row) {
+    const metadata = parseMetadata(row.metadata_json);
+    return {
+        runId: String(row.run_id),
+        projectRoot: String(row.project_root),
+        projectName: String(row.project_name),
+        status: row.status,
+        startedAt: String(row.started_at),
+        endedAt: row.ended_at === null ? null : String(row.ended_at),
+        ...(row.output === null || row.output === undefined ? {} : { output: String(row.output) }),
+        ...(metadata === undefined ? {} : { metadata }),
+    };
+}
+function rowToEvent(row) {
+    // Stored rows are trusted, not validated; pre-publication rows may have status and lack requestId and are not migrated.
+    const payload = JSON.parse(String(row.payload_json));
+    if (row.type === "artifact.file.written" && typeof payload.contentHash === "string") {
+        if (!(row.artifact_content instanceof Uint8Array)) {
+            // Missing artifact bodies make the canonical event log incomplete, so fail the read instead
+            // of returning a workspace that looks complete but silently omits an artifact version.
+            throw new Error(`Artifact content ${payload.contentHash} is missing from storage.`);
+        }
+        const bytes = Buffer.from(row.artifact_content);
+        payload.content =
+            payload.contentEncoding === "base64"
+                ? { encoding: "base64", data: bytes.toString("base64") }
+                : bytes.toString("utf8");
+        delete payload.contentEncoding;
+    }
+    return {
+        schemaVersion: 1,
+        streamType: runStreamType,
+        streamId: String(row.stream_id),
+        runId: String(row.stream_id),
+        id: String(row.event_id),
+        sequence: Number(row.sequence),
+        timestamp: String(row.timestamp),
+        type: row.type,
+        payload,
+    };
+}

package/dist/storage/sqlite/recover-interrupted.d.ts

@@ -0,0 +1,2 @@
+import type { DatabaseSync } from "node:sqlite";
+export declare function recoverInterruptedRuns(database: DatabaseSync): void;

package/dist/storage/sqlite/recover-interrupted.js

@@ -0,0 +1,46 @@
+import { runFailureEvents } from "../../events.js";
+import { ownerIsAlive } from "./owner-lock.js";
+export function recoverInterruptedRuns(database) {
+    if (!database
+        .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'run_owners'")
+        .get())
+        return;
+    if (!database.prepare("SELECT 1 FROM runs WHERE status = 'running' LIMIT 1").get())
+        return;
+    // Runs the engine journals resume from the journal instead of failing; see engine.recover.
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const rows = database
+            .prepare(`
+      SELECT runs.run_id, run_owners.owner_token, run_owners.owner_path FROM runs
+      LEFT JOIN run_owners ON run_owners.run_id = runs.run_id
+      WHERE runs.status = 'running'
+        AND runs.run_id NOT IN (SELECT run_id FROM engine_runs)
+    `)
+            .all();
+        // The write transaction serializes recovery with concurrent event appends and other openers.
+        for (const row of rows) {
+            if (row.owner_token !== null &&
+                row.owner_path !== null &&
+                ownerIsAlive(row.owner_token, row.owner_path))
+                continue;
+            // A running row always has run.started because both are written in one transaction.
+            const last = database
+                .prepare("SELECT sequence, type FROM events WHERE stream_type = 'run' AND stream_id = ? ORDER BY sequence DESC LIMIT 1")
+                .get(row.run_id);
+            const timestamp = new Date().toISOString();
+            const insert = database.prepare("INSERT INTO events (stream_type, stream_id, sequence, event_id, schema_version, type, timestamp, payload_json) VALUES ('run', ?, ?, ?, 1, ?, ?, ?)");
+            for (const event of runFailureEvents(row.run_id, last, "Run interrupted by process exit.", timestamp))
+                insert.run(event.streamId, event.sequence, event.id, event.type, event.timestamp, JSON.stringify(event.payload));
+            database
+                .prepare("UPDATE runs SET status = 'failed', ended_at = ? WHERE run_id = ? AND status = 'running'")
+                .run(timestamp, row.run_id);
+            database.prepare("DELETE FROM run_owners WHERE run_id = ?").run(row.run_id);
+        }
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+    }
+}

package/dist/storage/sqlite/schema.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from "node:sqlite";
+declare const migrations: ReadonlyArray<{
+    from: number;
+    to: number;
+    sql: string;
+}>;
+/** Read-only access must not silently accept an incompatible database. */
+export declare function checkReadOnlySchema(database: DatabaseSync): void;
+export declare function initializeSchema(database: DatabaseSync, steps?: typeof migrations): void;
+export {};

package/dist/storage/sqlite/schema.js

@@ -0,0 +1,205 @@
+const baselineVersion = 2;
+const migrations = [
+    {
+        from: 2,
+        to: 3,
+        sql: `
+    CREATE TABLE runs_new (
+      run_id TEXT PRIMARY KEY, project_root TEXT NOT NULL, project_name TEXT NOT NULL,
+      status TEXT NOT NULL, started_at TEXT NOT NULL, ended_at TEXT, output TEXT
+    );
+    INSERT INTO runs_new SELECT run_id, project_root, project_name, status, started_at, ended_at, output FROM runs;
+    DROP TABLE runs;
+    ALTER TABLE runs_new RENAME TO runs;
+    CREATE INDEX runs_started_at_index ON runs(started_at);
+  `,
+    },
+    {
+        from: 3,
+        to: 4,
+        sql: `CREATE TABLE run_owners (run_id TEXT PRIMARY KEY, process_id INTEGER NOT NULL, owner_token TEXT NOT NULL, owner_path TEXT NOT NULL);`,
+    },
+    {
+        // The execution engine's journal. These tables are private to the engine.
+        from: 4,
+        to: 5,
+        sql: `
+    CREATE TABLE engine_runs (
+      run_id TEXT PRIMARY KEY, state TEXT NOT NULL, input_json TEXT NOT NULL,
+      worker_id TEXT NOT NULL, lease_until INTEGER NOT NULL,
+      owner_token TEXT NOT NULL, owner_path TEXT NOT NULL
+    );
+    CREATE TABLE engine_steps (
+      run_id TEXT NOT NULL, step_index INTEGER NOT NULL, name TEXT NOT NULL, result_json TEXT NOT NULL,
+      PRIMARY KEY (run_id, step_index)
+    );
+  `,
+    },
+    {
+        from: 5,
+        to: 6,
+        sql: `
+    CREATE TABLE engine_waits (
+      run_id TEXT NOT NULL, name TEXT NOT NULL, deadline INTEGER, outcome_json TEXT,
+      PRIMARY KEY (run_id, name)
+    );
+    CREATE TABLE engine_signals (
+      run_id TEXT NOT NULL, name TEXT NOT NULL, value_json TEXT NOT NULL,
+      PRIMARY KEY (run_id, name)
+    );
+  `,
+    },
+    {
+        from: 6,
+        to: 7,
+        sql: `ALTER TABLE engine_runs ADD COLUMN cancel_requested INTEGER NOT NULL DEFAULT 0;`,
+    },
+    {
+        from: 7,
+        to: 8,
+        sql: `
+    CREATE TABLE threads (thread_id TEXT PRIMARY KEY, created_at TEXT NOT NULL);
+    CREATE TABLE thread_messages (message_id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, created_at TEXT NOT NULL, sequence INTEGER NOT NULL, FOREIGN KEY (thread_id) REFERENCES threads(thread_id));
+    CREATE INDEX thread_messages_thread_sequence ON thread_messages(thread_id, sequence);
+  `,
+    },
+    {
+        from: 8,
+        to: 9,
+        sql: `
+      ALTER TABLE thread_messages ADD COLUMN run_id TEXT;
+      CREATE TABLE thread_runs (run_id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, provider_key TEXT, project_root TEXT);
+      CREATE INDEX thread_runs_thread ON thread_runs(thread_id);
+      CREATE INDEX thread_messages_run ON thread_messages(run_id);
+      CREATE UNIQUE INDEX thread_assistant_run ON thread_messages(run_id) WHERE role = 'assistant';
+    `,
+    },
+    {
+        from: 9,
+        to: 10,
+        sql: `CREATE TABLE artifact_content (content_hash TEXT PRIMARY KEY, content TEXT NOT NULL);`,
+    },
+    {
+        from: 10,
+        to: 11,
+        sql: `
+      ALTER TABLE artifact_content RENAME TO artifact_content_text;
+      CREATE TABLE artifact_content (
+        content_hash TEXT PRIMARY KEY,
+        content BLOB NOT NULL
+      );
+      INSERT INTO artifact_content (content_hash, content)
+        SELECT content_hash, CAST(content AS BLOB) FROM artifact_content_text;
+      DROP TABLE artifact_content_text;
+    `,
+    },
+    {
+        from: 11,
+        to: 12,
+        sql: `ALTER TABLE threads ADD COLUMN title TEXT; ALTER TABLE threads ADD COLUMN title_source TEXT;`,
+    },
+    {
+        from: 12,
+        to: 13,
+        sql: `ALTER TABLE threads ADD COLUMN metadata_json TEXT; ALTER TABLE runs ADD COLUMN metadata_json TEXT; ALTER TABLE thread_runs ADD COLUMN context_json TEXT;`,
+    },
+    {
+        from: 13,
+        to: 14,
+        sql: `ALTER TABLE threads ADD COLUMN title_revision INTEGER NOT NULL DEFAULT 0;`,
+    },
+];
+function readSchemaVersion(database, sqliteSchemaVersion) {
+    const row = database.prepare("SELECT value FROM plico_meta WHERE key = 'schema_version'").get();
+    if (!row)
+        return undefined;
+    const version = Number(row.value);
+    if (!Number.isSafeInteger(version) || version < 1 || String(version) !== row.value) {
+        throw new Error(`Database has an invalid schema version (${row.value}).`);
+    }
+    if (version > sqliteSchemaVersion) {
+        throw new Error(`Database uses a newer schema (${version}, supported ${sqliteSchemaVersion}).`);
+    }
+    return version;
+}
+/** Read-only access must not silently accept an incompatible database. */
+export function checkReadOnlySchema(database) {
+    const latest = migrations.at(-1)?.to ?? baselineVersion;
+    const table = database
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'plico_meta'")
+        .get();
+    if (!table)
+        throw new Error("Database has no Plico schema version.");
+    const version = readSchemaVersion(database, latest);
+    if (version === undefined)
+        throw new Error("Database has no Plico schema version.");
+    if (version < latest)
+        throw new Error(`Database uses an older schema (${version}, supported ${latest}); open it writable to migrate.`);
+}
+export function initializeSchema(database, steps = migrations) {
+    const ordered = [...steps].sort((a, b) => a.from - b.from);
+    const sqliteSchemaVersion = ordered.at(-1)?.to ?? baselineVersion;
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        database.exec(`
+      CREATE TABLE IF NOT EXISTS plico_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+        let current = readSchemaVersion(database, sqliteSchemaVersion);
+        if (current === undefined) {
+            // `position` is the log-wide order from ADR 0007. Nothing reads it yet; it exists now so that
+            // thread streams need no second migration. It stays internal: public cursors are per stream.
+            database.exec(`
+        CREATE TABLE IF NOT EXISTS runs (
+          run_id TEXT PRIMARY KEY,
+          project_root TEXT NOT NULL,
+          project_name TEXT NOT NULL,
+          status TEXT NOT NULL,
+          started_at TEXT NOT NULL,
+          ended_at TEXT NOT NULL,
+          output TEXT
+        );
+        CREATE TABLE IF NOT EXISTS events (
+          position INTEGER PRIMARY KEY AUTOINCREMENT,
+          stream_type TEXT NOT NULL,
+          stream_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          event_id TEXT NOT NULL,
+          schema_version INTEGER NOT NULL,
+          type TEXT NOT NULL,
+          timestamp TEXT NOT NULL,
+          payload_json TEXT NOT NULL,
+          UNIQUE (stream_type, stream_id, sequence)
+        );
+        CREATE TABLE IF NOT EXISTS eval_reports (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          evaluated_at TEXT NOT NULL,
+          report_json TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS runs_started_at_index ON runs(started_at);
+      `);
+            database
+                .prepare("INSERT INTO plico_meta(key, value) VALUES ('schema_version', ?)")
+                .run(String(baselineVersion));
+            current = baselineVersion;
+        }
+        while (current < sqliteSchemaVersion) {
+            const migration = ordered.find((item) => item.from === current);
+            if (!migration || migration.to <= current) {
+                throw new Error(`Database uses an older schema (${current}) with no supported migration. Delete it or choose another path with --db.`);
+            }
+            database.exec(migration.sql);
+            current = migration.to;
+            database
+                .prepare("UPDATE plico_meta SET value = ? WHERE key = 'schema_version'")
+                .run(String(current));
+        }
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+    }
+}

package/dist/storage/sqlite/store.d.ts

@@ -0,0 +1,2 @@
+import type { CreateSqliteEventStoreOptions, EventStore } from "../../types/index.js";
+export declare function createSqliteEventStore({ databasePath, readOnly, }: CreateSqliteEventStoreOptions): EventStore;

package/dist/storage/sqlite/store.js

@@ -0,0 +1,51 @@
+import { resolve } from "node:path";
+import { matchesMetadata } from "../metadata.js";
+import { appendEventRecord } from "./append-event.js";
+import { openDatabase } from "./open.js";
+import { persistEvalReportRecord, readEvents, readLatestEvalReport, readRunSummaries, readRunSummary, readThreadRunEvents, readThreadRunEventsThrough, } from "./queries.js";
+import { recoverInterruptedRuns } from "./recover-interrupted.js";
+export function createSqliteEventStore({ databasePath, readOnly = false, }) {
+    const database = openDatabase(databasePath, readOnly);
+    if (!readOnly) {
+        try {
+            recoverInterruptedRuns(database);
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+    }
+    return {
+        ...(databasePath === ":memory:"
+            ? {}
+            : {
+                storageIdentity: process.platform === "win32"
+                    ? resolve(databasePath).toLowerCase()
+                    : resolve(databasePath),
+            }),
+        async appendEvent(event) {
+            appendEventRecord(database, event);
+        },
+        async listRuns(filter) {
+            return readRunSummaries(database).filter((run) => matchesMetadata(run.metadata, filter?.metadata));
+        },
+        async getRun(runId) {
+            return readRunSummary(database, runId);
+        },
+        async getEvents(runId, options = {}) {
+            return readEvents(database, runId, options.afterSequence);
+        },
+        async getThreadRunEvents(threadId) {
+            return readThreadRunEvents(database, threadId);
+        },
+        async getThreadRunEventsThrough(threadId, runId) {
+            return readThreadRunEventsThrough(database, threadId, runId);
+        },
+        async persistEvalReport(report) {
+            persistEvalReportRecord(database, report);
+        },
+        async getLatestEvalReport() {
+            return readLatestEvalReport(database);
+        },
+    };
+}

package/dist/storage/sqlite/thread-log.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { ThreadEvent } from "@plico-ai/contracts";
+/** Appends to a thread's own event stream and returns the new sequence number. */
+export declare function appendThreadEvent(db: DatabaseSync, threadId: string, type: ThreadEvent["type"], payload: unknown, timestamp: string): number;

package/dist/storage/sqlite/thread-log.js

@@ -0,0 +1,9 @@
+import { randomUUID } from "node:crypto";
+/** Appends to a thread's own event stream and returns the new sequence number. */
+export function appendThreadEvent(db, threadId, type, payload, timestamp) {
+    const row = db
+        .prepare("SELECT COALESCE(MAX(sequence), 0) + 1 AS next FROM events WHERE stream_type = 'thread' AND stream_id = ?")
+        .get(threadId);
+    db.prepare("INSERT INTO events (stream_type, stream_id, sequence, event_id, schema_version, type, timestamp, payload_json) VALUES ('thread', ?, ?, ?, 1, ?, ?, ?)").run(threadId, row.next, randomUUID(), type, timestamp, JSON.stringify(payload));
+    return row.next;
+}

package/dist/storage/sqlite/thread-title.d.ts

@@ -0,0 +1,24 @@
+import type { DatabaseSync } from "node:sqlite";
+/** Sets the title a user chose. It is never replaced by a generated one afterwards. */
+export declare function setUserTitle(db: DatabaseSync, threadId: string, title: string, timestamp: string): void;
+/** The transcript a titler should name, and the revision a title written from it belongs to. */
+export interface TitleRequest {
+    revision: number;
+    messages: Array<{
+        role: "user" | "assistant";
+        content: string;
+    }>;
+}
+/** The transcript to title now, or nothing when the thread is user-titled or past its exchanges. */
+export declare function getTitleRequest(db: DatabaseSync, threadId: string): TitleRequest | undefined;
+/**
+ * Stores a title a titler wrote after a reply. It never replaces a user's title, stops after the
+ * first exchanges like the keyword titler, and rejects a title written from an older transcript
+ * than the one behind the stored title. Returns whether the title changed.
+ */
+export declare function setGeneratedTitle(db: DatabaseSync, threadId: string, title: string, revision: number, timestamp: string): boolean;
+/**
+ * Names the thread from its transcript. Called inside the transaction that stores a reply, where
+ * a title is only a convenience: if naming fails, the reply is still stored and the run completes.
+ */
+export declare function retitleThread(db: DatabaseSync, threadId: string, timestamp: string): void;