stitchkit 0.85.2 → 0.87.0

package/dist/index-3yrqvza8.js

@@ -0,0 +1,964 @@
+import {
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema
+} from "./index-9553432s.js";
+import {
+  AgentAdmissionReceiptSchema,
+  AgentConversationPurgedError,
+  AgentHistoryMutationSchema,
+  AgentRuntimeHeadSchema,
+  AgentStoredRunSchema,
+  createAgentRuntimeStore
+} from "./index-5wezxcxx.js";
+import {
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventPageSchema,
+  AppendAgentStoreEventSchema,
+  agentStoreEventDraft,
+  canonicalAgentJson
+} from "./index-z1m86vc8.js";
+import {
+  AgentMessageSchema,
+  AgentRunSchema
+} from "./index-p1b1y93x.js";
+
+// src/agent-runtime/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+import { z as z2 } from "zod";
+
+// src/agent-runtime/sqlite-purge.ts
+var OWNED_TABLES = [
+  "stitchkit_agent_runtime_spills",
+  "stitchkit_agent_runtime_schedules",
+  "stitchkit_agent_runtime_projections",
+  "stitchkit_agent_runtime_events",
+  "stitchkit_agent_runtime_messages",
+  "stitchkit_agent_runtime_admissions",
+  "stitchkit_agent_runtime_runs",
+  "stitchkit_agent_runtime_heads"
+];
+function initializeSqliteConversationPurge(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_purged (
+      conversation_id TEXT PRIMARY KEY
+    );
+  `);
+  for (const table of OWNED_TABLES) {
+    for (const operation of ["INSERT", "UPDATE"]) {
+      database.exec(`
+        CREATE TRIGGER IF NOT EXISTS ${table}_purge_${operation.toLowerCase()}
+        BEFORE ${operation} ON ${table}
+        WHEN EXISTS (
+          SELECT 1 FROM stitchkit_agent_runtime_purged WHERE conversation_id = NEW.conversation_id
+        )
+        BEGIN SELECT RAISE(ABORT, 'Agent conversation has been purged'); END;
+      `);
+    }
+  }
+}
+function sqliteConversationPurge(database) {
+  const table = database.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'stitchkit_agent_runtime_purged'").get();
+  if (table === null || table === undefined)
+    return;
+  return {
+    async isPurged(transaction, conversationId) {
+      const row = transaction.prepare("SELECT conversation_id FROM stitchkit_agent_runtime_purged WHERE conversation_id = ?").get(conversationId);
+      return row !== null && row !== undefined;
+    },
+    async remove(transaction, conversationId) {
+      transaction.prepare("INSERT INTO stitchkit_agent_runtime_purged (conversation_id) VALUES (?)").run(conversationId);
+      for (const table2 of OWNED_TABLES) {
+        transaction.prepare(`DELETE FROM ${table2} WHERE conversation_id = ?`).run(conversationId);
+      }
+      transaction.prepare("DELETE FROM stitchkit_agent_runtime_children WHERE parent_conversation_id = ? OR child_conversation_id = ?").run(conversationId, conversationId);
+    }
+  };
+}
+
+// src/agent-runtime/store-migrations/v1-to-v2.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var ConversationRowSchema = z.object({
+  conversation_id: z.string().min(1),
+  version: z.int().nonnegative()
+});
+var PayloadRowSchema = z.object({
+  payload: z.string(),
+  terminal_assistant_payload: z.string().nullable().optional()
+});
+var HistoryRowSchema = z.object({
+  payload: z.string(),
+  active: z.union([z.literal(0), z.literal(1)])
+});
+var AdmissionRowSchema = z.object({
+  conversation_id: z.string(),
+  idempotency_key: z.string(),
+  input_payload: z.string(),
+  run_id: z.string(),
+  assistant_message_id: z.string()
+});
+function parseJson(value) {
+  return JSON.parse(value);
+}
+function createDurableTables(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_events (
+      row_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id TEXT NOT NULL,
+      seq INTEGER NOT NULL CHECK (seq > 0),
+      event_id TEXT NOT NULL UNIQUE,
+      schema_version INTEGER NOT NULL CHECK (schema_version > 0),
+      kind TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      ignorable INTEGER NOT NULL DEFAULT 0 CHECK (ignorable IN (0, 1)),
+      payload TEXT NOT NULL,
+      UNIQUE (conversation_id, seq)
+    );
+    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_events_time
+      ON stitchkit_agent_runtime_events (conversation_id, occurred_at, seq);
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_projections (
+      conversation_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      version INTEGER NOT NULL CHECK (version > 0),
+      upto_seq INTEGER NOT NULL CHECK (upto_seq >= 0),
+      payload TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (conversation_id, name)
+    );
+    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_projection_updates
+      ON stitchkit_agent_runtime_projections (name, updated_at, conversation_id);
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_spills (
+      reference_id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      run_id TEXT,
+      tool_call_id TEXT,
+      media_type TEXT NOT NULL,
+      bytes INTEGER NOT NULL CHECK (bytes >= 0),
+      sha256 TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT,
+      authorization_payload TEXT,
+      payload BLOB NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_spills_owner
+      ON stitchkit_agent_runtime_spills (conversation_id, created_at);
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_schedules (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      next_at TEXT NOT NULL,
+      interval_ms INTEGER,
+      time_zone TEXT,
+      input_payload TEXT NOT NULL,
+      state TEXT NOT NULL,
+      occurrence INTEGER NOT NULL DEFAULT 0 CHECK (occurrence >= 0),
+      claim_owner TEXT,
+      claim_until TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS stitchkit_agent_runtime_schedules_due
+      ON stitchkit_agent_runtime_schedules (state, next_at);
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_children (
+      parent_conversation_id TEXT NOT NULL,
+      child_conversation_id TEXT NOT NULL UNIQUE,
+      seed_upto_seq INTEGER,
+      state TEXT NOT NULL,
+      budget_payload TEXT NOT NULL,
+      usage_payload TEXT NOT NULL,
+      result_reference TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (parent_conversation_id, child_conversation_id)
+    );
+  `);
+  try {
+    database.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS stitchkit_agent_runtime_events_fts
+      USING fts5(
+        conversation_id UNINDEXED,
+        event_seq UNINDEXED,
+        occurred_at UNINDEXED,
+        body,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+      CREATE TRIGGER IF NOT EXISTS stitchkit_agent_runtime_events_fts_insert
+      AFTER INSERT ON stitchkit_agent_runtime_events BEGIN
+        INSERT INTO stitchkit_agent_runtime_events_fts(
+          rowid, conversation_id, event_seq, occurred_at, body
+        ) VALUES (new.row_id, new.conversation_id, new.seq, new.occurred_at, new.payload);
+      END;
+      CREATE TRIGGER IF NOT EXISTS stitchkit_agent_runtime_events_fts_delete
+      AFTER DELETE ON stitchkit_agent_runtime_events BEGIN
+        DELETE FROM stitchkit_agent_runtime_events_fts WHERE rowid = old.row_id;
+      END;
+    `);
+  } catch (error) {
+    throw new Error("SQLite agent-runtime requires FTS5 support", { cause: error });
+  }
+}
+function writeBaselines(database, migratedAt) {
+  const conversations = database.prepare("SELECT conversation_id, version FROM stitchkit_agent_runtime_heads ORDER BY conversation_id").all().map((row) => ConversationRowSchema.parse(row));
+  const insert = database.prepare(`
+    INSERT INTO stitchkit_agent_runtime_events (
+      conversation_id, seq, event_id, schema_version, kind, occurred_at, ignorable, payload
+    ) VALUES (?, 1, ?, 1, 'runtime/baseline', ?, 0, ?)
+  `);
+  for (const conversation of conversations) {
+    const rows = database.prepare("SELECT payload, active FROM stitchkit_agent_runtime_messages WHERE conversation_id = ? ORDER BY position, rowid").all(conversation.conversation_id).map((row) => {
+      const parsed = HistoryRowSchema.parse(row);
+      return {
+        message: AgentMessageSchema.parse(parseJson(parsed.payload)),
+        active: parsed.active === 1
+      };
+    });
+    const messages = rows.map((row) => row.message);
+    const compacted = rows.filter((row) => !row.active).map((row) => row.message.id);
+    const runs = database.prepare("SELECT payload, terminal_assistant_payload FROM stitchkit_agent_runtime_runs WHERE conversation_id = ? ORDER BY created_at, run_id").all(conversation.conversation_id).map((value) => {
+      const row = PayloadRowSchema.parse(value);
+      return {
+        schemaVersion: 1,
+        run: AgentRunSchema.parse(parseJson(row.payload)),
+        ...row.terminal_assistant_payload ? {
+          terminalAssistant: AgentMessageSchema.parse(parseJson(row.terminal_assistant_payload))
+        } : {}
+      };
+    });
+    const admissions = database.prepare("SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id FROM stitchkit_agent_runtime_admissions WHERE conversation_id = ? ORDER BY idempotency_key").all(conversation.conversation_id).map((value) => {
+      const row = AdmissionRowSchema.parse(value);
+      return {
+        schemaVersion: 1,
+        conversationId: row.conversation_id,
+        idempotencyKey: row.idempotency_key,
+        input: AgentMessageSchema.parse(parseJson(row.input_payload)),
+        runId: row.run_id,
+        assistantMessageId: row.assistant_message_id
+      };
+    });
+    const asOf = messages.at(-1)?.createdAt ?? runs.at(-1)?.run.createdAt;
+    insert.run(conversation.conversation_id, randomUUID(), migratedAt, canonicalAgentJson({
+      migratedAt,
+      ...asOf !== undefined && { asOf },
+      head: {
+        schemaVersion: 1,
+        conversationId: conversation.conversation_id,
+        version: conversation.version
+      },
+      messages,
+      ...compacted.length > 0 && { compacted },
+      runs,
+      admissions
+    }));
+  }
+}
+function migrateAgentRuntimeSqliteV1ToV2(database, migratedAt = new Date().toISOString()) {
+  createDurableTables(database);
+  writeBaselines(database, migratedAt);
+  database.prepare("UPDATE stitchkit_agent_runtime_meta SET value = '2' WHERE key = 'schema_version'").run();
+}
+function createAgentRuntimeSqliteV2Tables(database) {
+  createDurableTables(database);
+}
+
+// src/agent-runtime/sqlite.ts
+var HeadRowSchema = z2.object({ version: z2.number().int().nonnegative() });
+var RunRowSchema = z2.object({
+  payload: z2.string(),
+  terminal_assistant_payload: z2.string().nullable()
+});
+var AdmissionRowSchema2 = z2.object({
+  conversation_id: z2.string(),
+  idempotency_key: z2.string(),
+  input_payload: z2.string(),
+  run_id: z2.string(),
+  assistant_message_id: z2.string()
+});
+var MessageRowSchema = z2.object({ payload: z2.string() });
+var PositionedMessageRowSchema = z2.object({ position: z2.number().int().nonnegative() });
+var RecoverableRowSchema = z2.object({
+  conversation_id: z2.string(),
+  run_id: z2.string(),
+  payload: z2.string()
+});
+var MetaRowSchema = z2.object({ value: z2.string() });
+var TableRowSchema = z2.object({ name: z2.string() });
+var ConversationHeadRowSchema = z2.object({
+  conversation_id: z2.string(),
+  version: z2.number().int().nonnegative()
+});
+var CountRowSchema = z2.object({ count: z2.number().int().nonnegative() });
+var MessagePageRowSchema = z2.object({
+  row_id: z2.number().int().positive(),
+  position: z2.number().int().nonnegative(),
+  active: z2.union([z2.literal(0), z2.literal(1)]),
+  payload: z2.string()
+});
+var EventRowSchema = z2.object({
+  event_id: z2.string(),
+  conversation_id: z2.string(),
+  seq: z2.int().positive(),
+  schema_version: z2.int().positive(),
+  kind: z2.string(),
+  occurred_at: z2.string(),
+  ignorable: z2.union([z2.literal(0), z2.literal(1)]),
+  payload: z2.string()
+});
+var ArchiveProjectionRowSchema = z2.object({
+  name: z2.string(),
+  version: z2.int().positive(),
+  upto_seq: z2.int().nonnegative(),
+  payload: z2.string(),
+  updated_at: z2.string()
+});
+var ArchiveSpillRowSchema = z2.object({
+  reference_id: z2.string(),
+  run_id: z2.string().nullable(),
+  tool_call_id: z2.string().nullable(),
+  media_type: z2.string(),
+  bytes: z2.int().nonnegative(),
+  sha256: z2.string(),
+  created_at: z2.string(),
+  expires_at: z2.string().nullable(),
+  authorization_payload: z2.string().nullable(),
+  payload: z2.instanceof(Uint8Array)
+});
+var SCHEMA_VERSION = 2;
+var TABLES = [
+  "stitchkit_agent_runtime_heads",
+  "stitchkit_agent_runtime_runs",
+  "stitchkit_agent_runtime_admissions",
+  "stitchkit_agent_runtime_messages",
+  "stitchkit_agent_runtime_events",
+  "stitchkit_agent_runtime_projections",
+  "stitchkit_agent_runtime_spills",
+  "stitchkit_agent_runtime_schedules",
+  "stitchkit_agent_runtime_children"
+];
+function parseJson2(value) {
+  return JSON.parse(value);
+}
+function encodeJson(value) {
+  return JSON.stringify(value);
+}
+function missing(value) {
+  return value === null || value === undefined;
+}
+function placeholders(count) {
+  return Array.from({ length: count }, () => "?").join(", ");
+}
+function parseRunRow(value) {
+  const row = RunRowSchema.parse(value);
+  return AgentStoredRunSchema.parse({
+    schemaVersion: 1,
+    run: AgentRunSchema.parse(parseJson2(row.payload)),
+    ...row.terminal_assistant_payload === null ? {} : {
+      terminalAssistant: AgentMessageSchema.parse(parseJson2(row.terminal_assistant_payload))
+    }
+  });
+}
+function parseEventRow(value) {
+  const row = EventRowSchema.parse(value);
+  return AgentStoreEventEnvelopeSchema.parse({
+    schemaVersion: row.schema_version,
+    eventId: row.event_id,
+    conversationId: row.conversation_id,
+    seq: row.seq,
+    kind: row.kind,
+    occurredAt: row.occurred_at,
+    payload: parseJson2(row.payload),
+    ...row.ignorable === 1 && { ignorable: true }
+  });
+}
+function recoveryCursor(conversationId, runId) {
+  return encodeJson([conversationId, runId]);
+}
+function parseRecoveryCursor(cursor) {
+  return z2.tuple([z2.string().min(1), z2.string().min(1)]).parse(parseJson2(cursor));
+}
+function conversationCursor(conversationId) {
+  return encodeJson([conversationId]);
+}
+function parseConversationCursor(cursor) {
+  return z2.tuple([z2.string().min(1)]).parse(parseJson2(cursor))[0];
+}
+function messageCursor(position, rowId) {
+  return encodeJson([position, rowId]);
+}
+function parseMessageCursor(cursor) {
+  const parsed = z2.union([
+    z2.tuple([z2.int().nonnegative(), z2.int().positive()]),
+    z2.tuple([z2.int().nonnegative()])
+  ]).parse(parseJson2(cursor));
+  const [position, rowId] = parsed;
+  return { position, ...rowId !== undefined && { rowId } };
+}
+function messagePreview(message) {
+  const text = message.parts.find((part) => part.type === "text");
+  return text?.type === "text" ? text.text.slice(0, 160) : message.role;
+}
+function initializeAgentRuntimeSqlite(database) {
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const existing = database.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'stitchkit_agent_runtime_%' ORDER BY name`).all().map((row) => TableRowSchema.parse(row).name);
+    const hasMeta = existing.includes("stitchkit_agent_runtime_meta");
+    if (!hasMeta && existing.length > 0) {
+      throw new Error("Refusing an unversioned partial Stitchkit agent-runtime SQLite schema");
+    }
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    const versionRow = database.prepare("SELECT value FROM stitchkit_agent_runtime_meta WHERE key = 'schema_version'").get();
+    if (!missing(versionRow)) {
+      const version = Number(MetaRowSchema.parse(versionRow).value);
+      if (version === 1) {
+        migrateAgentRuntimeSqliteV1ToV2(database);
+        initializeSqliteConversationPurge(database);
+        database.exec("COMMIT");
+        return;
+      }
+      if (version !== SCHEMA_VERSION) {
+        throw new Error(`Unsupported Stitchkit agent-runtime SQLite schema version ${version}; expected ${SCHEMA_VERSION}`);
+      }
+      const missingTables = TABLES.filter((table) => !existing.includes(table));
+      if (missingTables.length > 0) {
+        throw new Error(`Refusing a partial Stitchkit agent-runtime SQLite schema; missing ${missingTables.join(", ")}`);
+      }
+      initializeSqliteConversationPurge(database);
+      database.exec("COMMIT");
+      return;
+    }
+    if (existing.some((table) => table !== "stitchkit_agent_runtime_meta")) {
+      throw new Error("Refusing an unversioned partial Stitchkit agent-runtime SQLite schema");
+    }
+    database.exec(`
+      CREATE TABLE stitchkit_agent_runtime_heads (
+        conversation_id TEXT PRIMARY KEY,
+        version INTEGER NOT NULL CHECK (version >= 0)
+      );
+      CREATE TABLE stitchkit_agent_runtime_runs (
+        conversation_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        assistant_message_id TEXT NOT NULL,
+        state TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        terminal_assistant_payload TEXT,
+        PRIMARY KEY (conversation_id, run_id),
+        UNIQUE (conversation_id, assistant_message_id)
+      );
+      CREATE INDEX stitchkit_agent_runtime_recoverable
+        ON stitchkit_agent_runtime_runs (state, conversation_id, run_id);
+      CREATE TABLE stitchkit_agent_runtime_admissions (
+        conversation_id TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL,
+        input_message_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        assistant_message_id TEXT NOT NULL,
+        input_payload TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, idempotency_key),
+        UNIQUE (conversation_id, input_message_id)
+      );
+      CREATE TABLE stitchkit_agent_runtime_messages (
+        conversation_id TEXT NOT NULL,
+        id TEXT NOT NULL,
+        position INTEGER NOT NULL CHECK (position >= 0),
+        active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1)),
+        payload TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, id)
+      );
+    `);
+    createAgentRuntimeSqliteV2Tables(database);
+    database.prepare("INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '2')").run();
+    initializeSqliteConversationPurge(database);
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+function createSqliteAgentRuntimeStore(config) {
+  const database = config.database;
+  if (config.initialize !== false) {
+    try {
+      initializeAgentRuntimeSqlite(database);
+    } catch (error) {
+      database.close();
+      throw error;
+    }
+  }
+  let closing = false;
+  let closed = false;
+  let tail = Promise.resolve();
+  const insideScope = new AsyncLocalStorage;
+  const serial = (work) => {
+    if (closing || closed) {
+      return Promise.reject(new Error("SQLite agent-runtime store is closing"));
+    }
+    if (insideScope.getStore()) {
+      return Promise.reject(new Error("SQLite agent-runtime store called from inside its own transaction scope; use scope.database and scope.appendEvent"));
+    }
+    const result = tail.then(work, work);
+    tail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+  const runTransaction = (access, work) => serial(async () => {
+    database.exec(access === "read" ? "BEGIN" : "BEGIN IMMEDIATE");
+    try {
+      const result = await work(database);
+      database.exec("COMMIT");
+      return result;
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+  });
+  const driver = {
+    conversations: sqliteConversationPurge(database),
+    transaction: (work, options) => runTransaction(options?.access ?? "write", work),
+    head: {
+      async load(transaction, conversationId) {
+        const value = transaction.prepare("SELECT version FROM stitchkit_agent_runtime_heads WHERE conversation_id = ?").get(conversationId);
+        if (missing(value))
+          return;
+        const row = HeadRowSchema.parse(value);
+        return AgentRuntimeHeadSchema.parse({
+          schemaVersion: 1,
+          conversationId,
+          version: row.version
+        });
+      },
+      async compareAndSwap(transaction, input) {
+        const current = transaction.prepare("SELECT version FROM stitchkit_agent_runtime_heads WHERE conversation_id = ?").get(input.conversationId);
+        const actualVersion = missing(current) ? 0 : HeadRowSchema.parse(current).version;
+        if (actualVersion !== input.expectedVersion)
+          return { outcome: "conflict", actualVersion };
+        transaction.prepare(`
+            INSERT INTO stitchkit_agent_runtime_heads (conversation_id, version)
+            VALUES (?, ?)
+            ON CONFLICT (conversation_id) DO UPDATE SET version = excluded.version
+          `).run(input.conversationId, input.next.version);
+        return { outcome: "applied" };
+      }
+    },
+    runs: {
+      async load(transaction, input) {
+        const row = transaction.prepare(`
+            SELECT payload, terminal_assistant_payload
+            FROM stitchkit_agent_runtime_runs
+            WHERE conversation_id = ? AND run_id = ?
+          `).get(input.conversationId, input.runId);
+        return missing(row) ? undefined : parseRunRow(row);
+      },
+      async loadByAssistantMessageId(transaction, input) {
+        const row = transaction.prepare(`
+            SELECT payload, terminal_assistant_payload
+            FROM stitchkit_agent_runtime_runs
+            WHERE conversation_id = ? AND assistant_message_id = ?
+          `).get(input.conversationId, input.assistantMessageId);
+        return missing(row) ? undefined : parseRunRow(row);
+      },
+      async loadMany(transaction, input) {
+        if (input.runIds.length === 0)
+          return [];
+        return transaction.prepare(`
+            SELECT payload, terminal_assistant_payload
+            FROM stitchkit_agent_runtime_runs
+            WHERE conversation_id = ? AND run_id IN (${placeholders(input.runIds.length)})
+          `).all(input.conversationId, ...input.runIds).map(parseRunRow);
+      },
+      async listActive(transaction, conversationId) {
+        return transaction.prepare(`
+            SELECT payload, terminal_assistant_payload
+            FROM stitchkit_agent_runtime_runs
+            WHERE conversation_id = ? AND state IN ('queued', 'running', 'interrupt_requested')
+          `).all(conversationId).map(parseRunRow);
+      },
+      async save(transaction, rawRecord) {
+        const record = AgentStoredRunSchema.parse(rawRecord);
+        transaction.prepare(`
+            INSERT INTO stitchkit_agent_runtime_runs (
+              conversation_id, run_id, assistant_message_id, state, created_at, payload,
+              terminal_assistant_payload
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (conversation_id, run_id) DO UPDATE SET
+              assistant_message_id = excluded.assistant_message_id,
+              state = excluded.state,
+              created_at = excluded.created_at,
+              payload = excluded.payload,
+              terminal_assistant_payload = excluded.terminal_assistant_payload
+          `).run(record.run.conversationId, record.run.id, record.run.assistantMessageId, record.run.state, record.run.createdAt, encodeJson(record.run), record.terminalAssistant ? encodeJson(record.terminalAssistant) : null);
+      }
+    },
+    admissions: {
+      async load(transaction, input) {
+        const value = transaction.prepare(`
+            SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id
+            FROM stitchkit_agent_runtime_admissions
+            WHERE conversation_id = ? AND idempotency_key = ?
+          `).get(input.conversationId, input.idempotencyKey);
+        if (missing(value))
+          return;
+        const row = AdmissionRowSchema2.parse(value);
+        return AgentAdmissionReceiptSchema.parse({
+          schemaVersion: 1,
+          conversationId: row.conversation_id,
+          idempotencyKey: row.idempotency_key,
+          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
+          runId: row.run_id,
+          assistantMessageId: row.assistant_message_id
+        });
+      },
+      async loadByInputMessageId(transaction, input) {
+        const value = transaction.prepare(`
+            SELECT conversation_id, idempotency_key, input_payload, run_id, assistant_message_id
+            FROM stitchkit_agent_runtime_admissions
+            WHERE conversation_id = ? AND input_message_id = ?
+          `).get(input.conversationId, input.inputMessageId);
+        if (missing(value))
+          return;
+        const row = AdmissionRowSchema2.parse(value);
+        return AgentAdmissionReceiptSchema.parse({
+          schemaVersion: 1,
+          conversationId: row.conversation_id,
+          idempotencyKey: row.idempotency_key,
+          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
+          runId: row.run_id,
+          assistantMessageId: row.assistant_message_id
+        });
+      },
+      async create(transaction, rawReceipt) {
+        const receipt = AgentAdmissionReceiptSchema.parse(rawReceipt);
+        transaction.prepare(`
+            INSERT INTO stitchkit_agent_runtime_admissions (
+              conversation_id, idempotency_key, input_message_id, run_id,
+              assistant_message_id, input_payload
+            ) VALUES (?, ?, ?, ?, ?, ?)
+          `).run(receipt.conversationId, receipt.idempotencyKey, receipt.input.id, receipt.runId, receipt.assistantMessageId, encodeJson(receipt.input));
+      }
+    },
+    history: {
+      async load(transaction, conversationId) {
+        return transaction.prepare(`
+            SELECT payload FROM stitchkit_agent_runtime_messages
+            WHERE conversation_id = ? AND active = 1 ORDER BY position ASC
+          `).all(conversationId).map((value) => AgentMessageSchema.parse(parseJson2(MessageRowSchema.parse(value).payload)));
+      },
+      async apply(transaction, rawMutation) {
+        const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+        const message = mutation.type === "admit" ? mutation.input : mutation.type === "upsert-assistant" ? mutation.message : mutation.summary;
+        if (mutation.type === "replace-compacted-range") {
+          const parameters = mutation.replacedMessageIds;
+          const rows = transaction.prepare(`
+              SELECT position FROM stitchkit_agent_runtime_messages
+              WHERE conversation_id = ? AND active = 1
+                AND id IN (${placeholders(parameters.length)})
+              ORDER BY position ASC
+            `).all(message.conversationId, ...parameters).map((row) => PositionedMessageRowSchema.parse(row));
+          const first = rows[0];
+          if (!first || rows.length !== parameters.length) {
+            throw new Error("Compaction range changed inside the transaction");
+          }
+          transaction.prepare(`
+              UPDATE stitchkit_agent_runtime_messages SET active = 0
+              WHERE conversation_id = ? AND id IN (${placeholders(parameters.length)})
+            `).run(message.conversationId, ...parameters);
+          transaction.prepare(`
+              INSERT INTO stitchkit_agent_runtime_messages
+                (conversation_id, id, position, active, payload)
+              VALUES (?, ?, ?, 1, ?)
+            `).run(message.conversationId, message.id, first.position, encodeJson(message));
+          return;
+        }
+        const existing = transaction.prepare(`
+            SELECT position FROM stitchkit_agent_runtime_messages
+            WHERE conversation_id = ? AND id = ?
+          `).get(message.conversationId, message.id);
+        if (!missing(existing)) {
+          transaction.prepare(`
+              UPDATE stitchkit_agent_runtime_messages SET payload = ?, active = 1
+              WHERE conversation_id = ? AND id = ?
+            `).run(encodeJson(message), message.conversationId, message.id);
+          return;
+        }
+        const last = transaction.prepare(`
+            SELECT position FROM stitchkit_agent_runtime_messages
+            WHERE conversation_id = ? ORDER BY position DESC LIMIT 1
+          `).get(message.conversationId);
+        const position = missing(last) ? 0 : PositionedMessageRowSchema.parse(last).position + 1;
+        transaction.prepare(`
+            INSERT INTO stitchkit_agent_runtime_messages
+              (conversation_id, id, position, active, payload)
+            VALUES (?, ?, ?, 1, ?)
+          `).run(message.conversationId, message.id, position, encodeJson(message));
+      }
+    },
+    events: {
+      async append(transaction, rawEvent) {
+        const event = rawEvent;
+        const last = transaction.prepare("SELECT COALESCE(MAX(seq), 0) AS count FROM stitchkit_agent_runtime_events WHERE conversation_id = ?").get(event.conversationId);
+        const seq = CountRowSchema.parse(last).count + 1;
+        transaction.prepare(`
+            INSERT INTO stitchkit_agent_runtime_events (
+              conversation_id, seq, event_id, schema_version, kind, occurred_at, ignorable, payload
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(event.conversationId, seq, event.eventId, event.schemaVersion, event.kind, event.occurredAt, event.ignorable ? 1 : 0, encodeJson(event.payload));
+        return AgentStoreEventEnvelopeSchema.parse({ ...event, seq });
+      },
+      async list(transaction, input) {
+        const clauses = ["conversation_id = ?"];
+        const values = [input.conversationId];
+        if (input.fromSeq !== undefined) {
+          clauses.push("seq >= ?");
+          values.push(input.fromSeq);
+        }
+        if (input.toSeq !== undefined) {
+          clauses.push("seq <= ?");
+          values.push(input.toSeq);
+        }
+        const rows = transaction.prepare(`
+            SELECT event_id, conversation_id, seq, schema_version, kind, occurred_at,
+              ignorable, payload
+            FROM stitchkit_agent_runtime_events
+            WHERE ${clauses.join(" AND ")}
+            ORDER BY seq ASC LIMIT ?
+          `).all(...values, input.limit + 1).map(parseEventRow);
+        const hasMore = rows.length > input.limit;
+        const items = rows.slice(0, input.limit);
+        const lastEvent = items.at(-1);
+        return AgentStoreEventPageSchema.parse({
+          items,
+          ...hasMore && lastEvent ? { nextSeq: lastEvent.seq + 1 } : {}
+        });
+      }
+    },
+    archive: {
+      async export(transaction, conversationId) {
+        const projections = transaction.prepare(`
+            SELECT name, version, upto_seq, payload, updated_at
+            FROM stitchkit_agent_runtime_projections
+            WHERE conversation_id = ? ORDER BY name
+          `).all(conversationId).map((raw) => {
+          const row = ArchiveProjectionRowSchema.parse(raw);
+          return {
+            name: row.name,
+            version: row.version,
+            uptoSeq: row.upto_seq,
+            value: z2.json().parse(parseJson2(row.payload)),
+            updatedAt: row.updated_at
+          };
+        });
+        const spills = transaction.prepare(`
+            SELECT reference_id, run_id, tool_call_id, media_type, bytes, sha256,
+              created_at, expires_at, authorization_payload, payload
+            FROM stitchkit_agent_runtime_spills
+            WHERE conversation_id = ? ORDER BY created_at, reference_id
+          `).all(conversationId).map((raw) => {
+          const row = ArchiveSpillRowSchema.parse(raw);
+          return {
+            reference: row.reference_id,
+            ...row.run_id && { runId: row.run_id },
+            ...row.tool_call_id && { toolCallId: row.tool_call_id },
+            mediaType: row.media_type,
+            bytes: row.bytes,
+            sha256: row.sha256,
+            createdAt: row.created_at,
+            ...row.expires_at && { expiresAt: row.expires_at },
+            ...row.authorization_payload && {
+              authorization: z2.json().parse(parseJson2(row.authorization_payload))
+            },
+            base64: Buffer.from(row.payload).toString("base64")
+          };
+        });
+        return { projections, spills };
+      },
+      async import(transaction, archive) {
+        for (const raw of archive.projections) {
+          if (typeof raw === "object" && raw !== null && !Array.isArray(raw) && raw.archiveType === "runtime-snapshot") {
+            continue;
+          }
+          const projection = z2.object({
+            name: z2.string(),
+            version: z2.int().positive(),
+            uptoSeq: z2.int().nonnegative(),
+            value: z2.json(),
+            updatedAt: z2.string()
+          }).strict().parse(raw);
+          transaction.prepare(`
+              INSERT INTO stitchkit_agent_runtime_projections
+                (conversation_id, name, version, upto_seq, payload, updated_at)
+              VALUES (?, ?, ?, ?, ?, ?)
+            `).run(archive.conversationId, projection.name, projection.version, projection.uptoSeq, encodeJson(projection.value), projection.updatedAt);
+        }
+        for (const raw of archive.spills) {
+          const spill = z2.object({
+            reference: z2.string(),
+            runId: z2.string().optional(),
+            toolCallId: z2.string().optional(),
+            mediaType: z2.string(),
+            bytes: z2.int().nonnegative(),
+            sha256: z2.string(),
+            createdAt: z2.string(),
+            expiresAt: z2.string().optional(),
+            authorization: z2.json().optional(),
+            base64: z2.string()
+          }).strict().parse(raw);
+          const payload = Buffer.from(spill.base64, "base64");
+          if (payload.byteLength !== spill.bytes) {
+            throw new TypeError("Conversation archive spill byte count is inconsistent");
+          }
+          if (createHash("sha256").update(payload).digest("hex") !== spill.sha256) {
+            throw new TypeError("Conversation archive spill digest is inconsistent");
+          }
+          transaction.prepare(`
+              INSERT INTO stitchkit_agent_runtime_spills (
+                reference_id, conversation_id, run_id, tool_call_id, media_type,
+                bytes, sha256, created_at, expires_at, authorization_payload, payload
+              ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(spill.reference, archive.conversationId, spill.runId ?? null, spill.toolCallId ?? null, spill.mediaType, spill.bytes, spill.sha256, spill.createdAt, spill.expiresAt ?? null, spill.authorization ? encodeJson(spill.authorization) : null, payload);
+        }
+      }
+    },
+    scanRecoverable: (input) => runTransaction("read", async () => {
+      const cursor = input.cursor ? parseRecoveryCursor(input.cursor) : undefined;
+      const values = cursor ? [cursor[0], cursor[0], cursor[1], input.limit + 1] : [input.limit + 1];
+      const rows = database.prepare(`
+            SELECT conversation_id, run_id, payload
+            FROM stitchkit_agent_runtime_runs
+            WHERE state IN ('queued', 'running', 'interrupt_requested')
+            ${cursor ? "AND (conversation_id > ? OR (conversation_id = ? AND run_id > ?))" : ""}
+            ORDER BY conversation_id ASC, run_id ASC LIMIT ?
+          `).all(...values).map((row) => RecoverableRowSchema.parse(row));
+      const hasMore = rows.length > input.limit;
+      const pageRows = rows.slice(0, input.limit);
+      const items = pageRows.map((row) => {
+        const run = AgentRunSchema.parse(parseJson2(row.payload));
+        return AgentRecoverableDescriptorSchema.parse({
+          conversationId: row.conversation_id,
+          run
+        });
+      });
+      const last = pageRows.at(-1);
+      return AgentRecoverablePageSchema.parse({
+        items,
+        ...hasMore && last ? { nextCursor: recoveryCursor(last.conversation_id, last.run_id) } : {}
+      });
+    })
+  };
+  return {
+    store: createAgentRuntimeStore(driver),
+    database,
+    transaction: (work) => runTransaction("write", (transaction) => insideScope.run(true, () => work({
+      database: transaction,
+      appendEvent: async (input) => {
+        const parsed = AppendAgentStoreEventSchema.parse(input);
+        if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+          throw new AgentConversationPurgedError;
+        }
+        return driver.events.append(transaction, agentStoreEventDraft(parsed));
+      }
+    }))),
+    conversations: {
+      list: (input) => runTransaction("read", async () => {
+        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
+          throw new TypeError("Conversation page limit must be between 1 and 1000");
+        }
+        const cursor = input.cursor ? parseConversationCursor(input.cursor) : undefined;
+        const search = input.search?.trim();
+        const clauses = [
+          ...cursor ? ["conversation_id > ?"] : [],
+          ...search ? ["instr(conversation_id, ?) > 0"] : []
+        ];
+        const parameters = [
+          ...cursor ? [cursor] : [],
+          ...search ? [search] : [],
+          input.limit + 1
+        ];
+        const rows = database.prepare(`
+              SELECT conversation_id, version FROM stitchkit_agent_runtime_heads
+              ${clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : ""}
+              ORDER BY conversation_id ASC LIMIT ?
+            `).all(...parameters).map((row) => ConversationHeadRowSchema.parse(row));
+        const hasMore = rows.length > input.limit;
+        const pageRows = rows.slice(0, input.limit);
+        const items = pageRows.map((row) => {
+          const latestRaw = database.prepare(`
+                SELECT payload FROM stitchkit_agent_runtime_messages
+                WHERE conversation_id = ? AND active = 1
+                ORDER BY position DESC LIMIT 1
+              `).get(row.conversation_id);
+          if (missing(latestRaw)) {
+            throw new Error("Agent conversation head has no active history");
+          }
+          const latest = AgentMessageSchema.parse(parseJson2(MessageRowSchema.parse(latestRaw).payload));
+          const active = CountRowSchema.parse(database.prepare(`
+                  SELECT count(*) AS count FROM stitchkit_agent_runtime_runs
+                  WHERE conversation_id = ?
+                    AND state IN ('queued', 'running', 'interrupt_requested')
+                `).get(row.conversation_id));
+          return {
+            conversationId: row.conversation_id,
+            version: row.version,
+            updatedAt: latest.updatedAt,
+            preview: messagePreview(latest),
+            activeRuns: active.count
+          };
+        });
+        const last = pageRows.at(-1);
+        return AgentConversationPageSchema.parse({
+          items,
+          ...hasMore && last ? { nextCursor: conversationCursor(last.conversation_id) } : {}
+        });
+      }),
+      messages: (input) => runTransaction("read", async () => {
+        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1000) {
+          throw new TypeError("Conversation message page limit must be between 1 and 1000");
+        }
+        const cursor = input.cursor ? parseMessageCursor(input.cursor) : undefined;
+        const before = input.direction === "before";
+        const direction = before ? "DESC" : "ASC";
+        const comparison = cursor === undefined ? "" : cursor.rowId === undefined ? `AND position ${before ? "<" : ">"} ?` : `AND (position, rowid) ${before ? "<" : ">"} (?, ?)`;
+        const rows = database.prepare(`
+              SELECT rowid AS row_id, position, active, payload
+              FROM stitchkit_agent_runtime_messages
+              WHERE conversation_id = ?
+              ${input.includeCompacted === true ? "" : "AND active = 1"}
+              ${comparison}
+              ORDER BY position ${direction}, rowid ${direction} LIMIT ?
+            `).all(input.conversationId, ...cursor === undefined ? [] : cursor.rowId === undefined ? [cursor.position] : [cursor.position, cursor.rowId], input.limit + 1).map((row) => MessagePageRowSchema.parse(row));
+        const hasMore = rows.length > input.limit;
+        const pageRows = rows.slice(0, input.limit);
+        const ordered = before ? [...pageRows].reverse() : pageRows;
+        const boundary = pageRows.at(-1);
+        const items = ordered.map((row) => ({
+          message: AgentMessageSchema.parse(parseJson2(row.payload)),
+          active: row.active === 1
+        }));
+        return AgentConversationMessagePageSchema.parse({
+          items: items.map((entry) => entry.message),
+          compacted: items.filter((entry) => !entry.active).map((entry) => entry.message.id),
+          ...hasMore && boundary ? { nextCursor: messageCursor(boundary.position, boundary.row_id) } : {}
+        });
+      })
+    },
+    async close() {
+      if (closed)
+        return;
+      closing = true;
+      await tail;
+      database.close();
+      closed = true;
+    }
+  };
+}
+
+export { initializeAgentRuntimeSqlite, createSqliteAgentRuntimeStore };