stitchkit 0.93.0 → 0.94.0

package/dist/index-mp5sn43f.js

@@ -0,0 +1,1084 @@
+import {
+  AgentConversationMessagePageSchema,
+  AgentConversationPageSchema
+} from "./index-crykmqkr.js";
+import {
+  AgentAdmissionReceiptSchema,
+  AgentHistoryMutationSchema,
+  AgentRuntimeHeadSchema,
+  AgentSeedReceiptSchema,
+  AgentStoredRunSchema,
+  appendEventIn,
+  createAgentRuntimeStore
+} from "./index-58k4fp34.js";
+import {
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventPageSchema,
+  AppendAgentStoreEventSchema,
+  canonicalAgentJson
+} from "./index-1nd48tm9.js";
+import {
+  AgentMessageSchema,
+  AgentRunSchema
+} from "./index-gtj3zc53.js";
+
+// src/agent-runtime/sqlite-schema.ts
+import { z as z3 } 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_seeds",
+  "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/sqlite-rows.ts
+import { z } from "zod";
+var HeadRowSchema = z.object({ version: z.number().int().nonnegative() });
+var RunRowSchema = z.object({
+  payload: z.string(),
+  terminal_assistant_payload: z.string().nullable()
+});
+var MessageRowSchema = z.object({ payload: z.string() });
+var PositionedMessageRowSchema = z.object({
+  position: z.number().int().nonnegative()
+});
+var CountRowSchema = z.object({ count: z.number().int().nonnegative() });
+var EventRowSchema = z.object({
+  event_id: z.string(),
+  conversation_id: z.string(),
+  seq: z.int().positive(),
+  schema_version: z.int().positive(),
+  kind: z.string(),
+  occurred_at: z.string(),
+  ignorable: z.union([z.literal(0), z.literal(1)]),
+  payload: z.string()
+});
+function parseJson(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(parseJson(row.payload)),
+    ...row.terminal_assistant_payload === null ? {} : {
+      terminalAssistant: AgentMessageSchema.parse(parseJson(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: parseJson(row.payload),
+    ...row.ignorable === 1 && { ignorable: true }
+  });
+}
+
+// src/agent-runtime/store-migrations/v1-to-v2.ts
+import { randomUUID } from "node:crypto";
+import { z as z2 } from "zod";
+var ConversationRowSchema = z2.object({
+  conversation_id: z2.string().min(1),
+  version: z2.int().nonnegative()
+});
+var PayloadRowSchema = z2.object({
+  payload: z2.string(),
+  terminal_assistant_payload: z2.string().nullable().optional()
+});
+var HistoryRowSchema = z2.object({
+  payload: z2.string(),
+  active: z2.union([z2.literal(0), z2.literal(1)])
+});
+var AdmissionRowSchema = z2.object({
+  conversation_id: z2.string(),
+  idempotency_key: z2.string(),
+  input_payload: z2.string(),
+  run_id: z2.string(),
+  assistant_message_id: z2.string()
+});
+function parseJson2(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(parseJson2(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(parseJson2(row.payload)),
+        ...row.terminal_assistant_payload ? {
+          terminalAssistant: AgentMessageSchema.parse(parseJson2(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(parseJson2(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/store-migrations/v2-to-v3.ts
+function createAgentRuntimeSqliteV3Tables(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS stitchkit_agent_runtime_seeds (
+      conversation_id TEXT NOT NULL,
+      seed_key TEXT NOT NULL,
+      message_ids TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (conversation_id, seed_key)
+    );
+  `);
+}
+function migrateAgentRuntimeSqliteV2ToV3(database) {
+  createAgentRuntimeSqliteV3Tables(database);
+  database.prepare("UPDATE stitchkit_agent_runtime_meta SET value = '3' WHERE key = 'schema_version'").run();
+}
+
+// src/agent-runtime/sqlite-schema.ts
+var MetaRowSchema = z3.object({ value: z3.string() });
+var TableRowSchema = z3.object({ name: z3.string() });
+var SCHEMA_VERSION = 3;
+var TABLES = [
+  "stitchkit_agent_runtime_heads",
+  "stitchkit_agent_runtime_runs",
+  "stitchkit_agent_runtime_admissions",
+  "stitchkit_agent_runtime_messages",
+  "stitchkit_agent_runtime_seeds",
+  "stitchkit_agent_runtime_events",
+  "stitchkit_agent_runtime_projections",
+  "stitchkit_agent_runtime_spills",
+  "stitchkit_agent_runtime_schedules",
+  "stitchkit_agent_runtime_children"
+];
+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);
+        migrateAgentRuntimeSqliteV2ToV3(database);
+        initializeSqliteConversationPurge(database);
+        database.exec("COMMIT");
+        return;
+      }
+      if (version === 2) {
+        migrateAgentRuntimeSqliteV2ToV3(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);
+    createAgentRuntimeSqliteV3Tables(database);
+    database.prepare("INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '3')").run();
+    initializeSqliteConversationPurge(database);
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+// src/agent-runtime/sqlite-events.ts
+import { createHash } from "node:crypto";
+import { z as z4 } from "zod";
+var ArchiveProjectionRowSchema = z4.object({
+  name: z4.string(),
+  version: z4.int().positive(),
+  upto_seq: z4.int().nonnegative(),
+  payload: z4.string(),
+  updated_at: z4.string()
+});
+var ArchiveSpillRowSchema = z4.object({
+  reference_id: z4.string(),
+  run_id: z4.string().nullable(),
+  tool_call_id: z4.string().nullable(),
+  media_type: z4.string(),
+  bytes: z4.int().nonnegative(),
+  sha256: z4.string(),
+  created_at: z4.string(),
+  expires_at: z4.string().nullable(),
+  authorization_payload: z4.string().nullable(),
+  payload: z4.instanceof(Uint8Array)
+});
+var sqliteEvents = {
+  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 } : {}
+    });
+  }
+};
+var sqliteArchive = {
+  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: z4.json().parse(parseJson(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: z4.json().parse(parseJson(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 = z4.object({
+        name: z4.string(),
+        version: z4.int().positive(),
+        uptoSeq: z4.int().nonnegative(),
+        value: z4.json(),
+        updatedAt: z4.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 = z4.object({
+        reference: z4.string(),
+        runId: z4.string().optional(),
+        toolCallId: z4.string().optional(),
+        mediaType: z4.string(),
+        bytes: z4.int().nonnegative(),
+        sha256: z4.string(),
+        createdAt: z4.string(),
+        expiresAt: z4.string().optional(),
+        authorization: z4.json().optional(),
+        base64: z4.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);
+    }
+  }
+};
+
+// src/agent-runtime/sqlite-history.ts
+var sqliteHistory = {
+  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(parseJson(MessageRowSchema.parse(value).payload)));
+  },
+  async hasMessage(transaction, input) {
+    const row = transaction.prepare(`
+        SELECT count(*) AS count FROM stitchkit_agent_runtime_messages
+        WHERE conversation_id = ? AND id = ?
+      `).get(input.conversationId, input.messageId);
+    return CountRowSchema.parse(row).count > 0;
+  },
+  async apply(transaction, rawMutation) {
+    const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+    const message = mutation.type === "admit" ? mutation.input : mutation.type === "upsert-assistant" ? mutation.message : mutation.type === "seed" ? mutation.message : mutation.summary;
+    if (mutation.type === "seed") {
+      transaction.prepare(`
+          UPDATE stitchkit_agent_runtime_messages SET position = position + 1
+          WHERE conversation_id = ?
+        `).run(mutation.message.conversationId);
+      transaction.prepare(`
+          INSERT INTO stitchkit_agent_runtime_messages
+            (conversation_id, id, position, active, payload)
+          VALUES (?, ?, 0, 1, ?)
+          ON CONFLICT (conversation_id, id) DO UPDATE SET
+            position = excluded.position,
+            active = excluded.active,
+            payload = excluded.payload
+        `).run(mutation.message.conversationId, mutation.message.id, encodeJson(mutation.message));
+      return;
+    }
+    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 anchor = rows.at(-1);
+      if (!anchor || 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, anchor.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));
+  }
+};
+
+// src/agent-runtime/sqlite-ledger.ts
+import { z as z5 } from "zod";
+var AdmissionRowSchema2 = z5.object({
+  conversation_id: z5.string(),
+  idempotency_key: z5.string(),
+  input_payload: z5.string(),
+  run_id: z5.string(),
+  assistant_message_id: z5.string()
+});
+var SeedRowSchema = z5.object({
+  conversation_id: z5.string(),
+  seed_key: z5.string(),
+  message_ids: z5.string()
+});
+function parseAdmissionRow(value) {
+  const row = AdmissionRowSchema2.parse(value);
+  return AgentAdmissionReceiptSchema.parse({
+    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
+  });
+}
+var sqliteHeads = {
+  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" };
+  }
+};
+var sqliteRuns = {
+  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);
+  }
+};
+var sqliteAdmissions = {
+  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);
+    return missing(value) ? undefined : parseAdmissionRow(value);
+  },
+  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);
+    return missing(value) ? undefined : parseAdmissionRow(value);
+  },
+  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));
+  }
+};
+var sqliteSeeds = {
+  async load(transaction, input) {
+    const value = transaction.prepare(`
+        SELECT conversation_id, seed_key, message_ids
+        FROM stitchkit_agent_runtime_seeds
+        WHERE conversation_id = ? AND seed_key = ?
+      `).get(input.conversationId, input.seedKey);
+    if (missing(value))
+      return;
+    const row = SeedRowSchema.parse(value);
+    return AgentSeedReceiptSchema.parse({
+      schemaVersion: 1,
+      conversationId: row.conversation_id,
+      seedKey: row.seed_key,
+      messageIds: z5.array(z5.string().min(1)).parse(parseJson(row.message_ids))
+    });
+  },
+  async create(transaction, rawReceipt) {
+    const receipt = AgentSeedReceiptSchema.parse(rawReceipt);
+    transaction.prepare(`
+        INSERT INTO stitchkit_agent_runtime_seeds (
+          conversation_id, seed_key, message_ids, created_at
+        ) VALUES (?, ?, ?, ?)
+      `).run(receipt.conversationId, receipt.seedKey, encodeJson(receipt.messageIds), new Date().toISOString());
+  }
+};
+
+// src/agent-runtime/sqlite-reads.ts
+import { z as z6 } from "zod";
+
+// src/agent-runtime/sqlite-transactions.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function createSqliteStoreState(database) {
+  return {
+    database,
+    closing: false,
+    closed: false,
+    tail: Promise.resolve(),
+    insideScope: new AsyncLocalStorage
+  };
+}
+function serial(state, work) {
+  if (state.closing || state.closed) {
+    return Promise.reject(new Error("SQLite agent-runtime store is closing"));
+  }
+  if (state.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 = state.tail.then(work, work);
+  state.tail = result.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return result;
+}
+function runSqliteTransaction(state, access, work) {
+  const database = state.database;
+  return serial(state, 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;
+    }
+  });
+}
+function runSqliteStoreScope(state, driver, work) {
+  return runSqliteTransaction(state, "write", (transaction) => state.insideScope.run(true, () => work({
+    database: transaction,
+    appendEvent: (input) => appendEventIn(driver, transaction, AppendAgentStoreEventSchema.parse(input))
+  })));
+}
+async function closeSqliteStore(state) {
+  if (state.closed)
+    return;
+  state.closing = true;
+  await state.tail;
+  state.database.close();
+  state.closed = true;
+}
+
+// src/agent-runtime/sqlite-reads.ts
+var RecoverableRowSchema = z6.object({
+  conversation_id: z6.string(),
+  run_id: z6.string(),
+  payload: z6.string()
+});
+var ConversationHeadRowSchema = z6.object({
+  conversation_id: z6.string(),
+  version: z6.number().int().nonnegative()
+});
+var MessagePageRowSchema = z6.object({
+  row_id: z6.number().int().positive(),
+  position: z6.number().int().nonnegative(),
+  active: z6.union([z6.literal(0), z6.literal(1)]),
+  payload: z6.string()
+});
+function recoveryCursor(conversationId, runId) {
+  return encodeJson([conversationId, runId]);
+}
+function parseRecoveryCursor(cursor) {
+  return z6.tuple([z6.string().min(1), z6.string().min(1)]).parse(parseJson(cursor));
+}
+function conversationCursor(conversationId) {
+  return encodeJson([conversationId]);
+}
+function parseConversationCursor(cursor) {
+  return z6.tuple([z6.string().min(1)]).parse(parseJson(cursor))[0];
+}
+function messageCursor(position, rowId) {
+  return encodeJson([position, rowId]);
+}
+function parseMessageCursor(cursor) {
+  const parsed = z6.union([
+    z6.tuple([z6.int().nonnegative(), z6.int().positive()]),
+    z6.tuple([z6.int().nonnegative()])
+  ]).parse(parseJson(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 scanSqliteRecoverable(state, input) {
+  const database = state.database;
+  return runSqliteTransaction(state, "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(parseJson(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) } : {}
+    });
+  });
+}
+function listSqliteConversations(state, input) {
+  const database = state.database;
+  return runSqliteTransaction(state, "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(parseJson(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) } : {}
+    });
+  });
+}
+function pageSqliteConversationMessages(state, input) {
+  const database = state.database;
+  return runSqliteTransaction(state, "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(parseJson(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) } : {}
+    });
+  });
+}
+
+// src/agent-runtime/sqlite.ts
+function createSqliteAgentRuntimeStore(config) {
+  const database = config.database;
+  if (config.initialize !== false) {
+    try {
+      initializeAgentRuntimeSqlite(database);
+    } catch (error) {
+      database.close();
+      throw error;
+    }
+  }
+  const state = createSqliteStoreState(database);
+  const driver = {
+    conversations: sqliteConversationPurge(database),
+    transaction: (work, options) => runSqliteTransaction(state, options?.access ?? "write", work),
+    head: sqliteHeads,
+    runs: sqliteRuns,
+    admissions: sqliteAdmissions,
+    seeds: sqliteSeeds,
+    history: sqliteHistory,
+    events: sqliteEvents,
+    archive: sqliteArchive,
+    scanRecoverable: (input) => scanSqliteRecoverable(state, input)
+  };
+  return {
+    store: createAgentRuntimeStore(driver),
+    database,
+    transaction: (work) => runSqliteStoreScope(state, driver, work),
+    conversations: {
+      list: (input) => listSqliteConversations(state, input),
+      messages: (input) => pageSqliteConversationMessages(state, input)
+    },
+    close: () => closeSqliteStore(state)
+  };
+}
+
+export { initializeAgentRuntimeSqlite, createSqliteAgentRuntimeStore };