stitchkit 0.85.2 → 0.86.0

package/dist/{index-27487ay5.js → index-9hw9eq48.js}

@@ -3,19 +3,19 @@ import {
 } from "./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-s4ckmrac.js";
+} from "./index-rcgsnrr6.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-fwbkp2jn.js";
+} from "./index-0vfdh685.js";
 import {
   toolResultFromError
-} from "./index-dggwnnjv.js";
+} from "./index-wn9cb82y.js";
 import {
   assertUniqueToolName,
   buildToolPresentationSchema,
   objectShapeKeys
-} from "./index-mgtxfe6b.js";
+} from "./index-r159gjwy.js";
 import {
   jsonSchemaFields
 } from "./index-cby4ar3v.js";

package/dist/{index-66nxrgy0.js → index-b7qwhbzq.js}

@@ -2,23 +2,37 @@ import {
   AgentAdmissionReceiptSchema,
   AgentConversationMessagePageSchema,
   AgentConversationPageSchema,
+  AgentConversationPurgedError,
   AgentHistoryMutationSchema,
-  AgentRecoverableDescriptorSchema,
-  AgentRecoverablePageSchema,
   AgentRuntimeHeadSchema,
   AgentStoredRunSchema,
   createAgentRuntimeStore
-} from "./index-fq492hg0.js";
+} from "./index-hber83mk.js";
+import {
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventPageSchema,
+  AppendAgentStoreEventSchema,
+  agentStoreEventDraft,
+  canonicalAgentJson
+} from "./index-vfgb58nf.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
-} from "./index-x15ss2dx.js";
+} from "./index-p1b1y93x.js";
 
 // src/agent-runtime/sqlite.ts
-import { z } from "zod";
+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",
@@ -57,15 +71,21 @@ function sqliteConversationPurge(database) {
       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.ts
-var HeadRowSchema = z.object({ version: z.number().int().nonnegative() });
-var RunRowSchema = z.object({
+// 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()
+  terminal_assistant_payload: z.string().nullable().optional()
 });
 var AdmissionRowSchema = z.object({
   conversation_id: z.string(),
@@ -74,32 +94,233 @@ var AdmissionRowSchema = z.object({
   run_id: z.string(),
   assistant_message_id: z.string()
 });
-var MessageRowSchema = z.object({ payload: z.string() });
-var PositionedMessageRowSchema = z.object({ position: z.number().int().nonnegative() });
-var RecoverableRowSchema = z.object({
-  conversation_id: z.string(),
-  run_id: z.string(),
-  payload: 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 messages = database.prepare("SELECT payload FROM stitchkit_agent_runtime_messages WHERE conversation_id = ? AND active = 1 ORDER BY position").all(conversation.conversation_id).map((row) => AgentMessageSchema.parse(parseJson(PayloadRowSchema.parse(row).payload)));
+    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,
+      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 MetaRowSchema = z.object({ value: z.string() });
-var TableRowSchema = z.object({ name: z.string() });
-var ConversationHeadRowSchema = z.object({
-  conversation_id: z.string(),
-  version: z.number().int().nonnegative()
+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 = z.object({ count: z.number().int().nonnegative() });
-var MessagePageRowSchema = z.object({
-  position: z.number().int().nonnegative(),
-  payload: z.string()
+var CountRowSchema = z2.object({ count: z2.number().int().nonnegative() });
+var MessagePageRowSchema = z2.object({
+  position: z2.number().int().nonnegative(),
+  payload: z2.string()
 });
-var SCHEMA_VERSION = 1;
+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_messages",
+  "stitchkit_agent_runtime_events",
+  "stitchkit_agent_runtime_projections",
+  "stitchkit_agent_runtime_spills",
+  "stitchkit_agent_runtime_schedules",
+  "stitchkit_agent_runtime_children"
 ];
-function parseJson(value) {
+function parseJson2(value) {
   return JSON.parse(value);
 }
 function encodeJson(value) {
@@ -115,42 +336,55 @@ function parseRunRow(value) {
   const row = RunRowSchema.parse(value);
   return AgentStoredRunSchema.parse({
     schemaVersion: 1,
-    run: AgentRunSchema.parse(parseJson(row.payload)),
+    run: AgentRunSchema.parse(parseJson2(row.payload)),
     ...row.terminal_assistant_payload === null ? {} : {
-      terminalAssistant: AgentMessageSchema.parse(parseJson(row.terminal_assistant_payload))
+      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 z.tuple([z.string().min(1), z.string().min(1)]).parse(parseJson(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 z.tuple([z.string().min(1)]).parse(parseJson(cursor))[0];
+  return z2.tuple([z2.string().min(1)]).parse(parseJson2(cursor))[0];
 }
 function messageCursor(position) {
   return encodeJson([position]);
 }
 function parseMessageCursor(cursor) {
-  return z.tuple([z.int().nonnegative()]).parse(parseJson(cursor))[0];
+  return z2.tuple([z2.int().nonnegative()]).parse(parseJson2(cursor))[0];
 }
 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) {
-  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("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,
@@ -160,6 +394,12 @@ function initializeAgentRuntimeSqlite(database) {
     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}`);
       }
@@ -210,8 +450,9 @@ function initializeAgentRuntimeSqlite(database) {
         payload TEXT NOT NULL,
         PRIMARY KEY (conversation_id, id)
       );
-      INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '1');
     `);
+    createAgentRuntimeSqliteV2Tables(database);
+    database.prepare("INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '2')").run();
     initializeSqliteConversationPurge(database);
     database.exec("COMMIT");
   } catch (error) {
@@ -232,10 +473,14 @@ function createSqliteAgentRuntimeStore(config) {
   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;
@@ -344,12 +589,12 @@ function createSqliteAgentRuntimeStore(config) {
           `).get(input.conversationId, input.idempotencyKey);
         if (missing(value))
           return;
-        const row = AdmissionRowSchema.parse(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)),
+          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
           runId: row.run_id,
           assistantMessageId: row.assistant_message_id
         });
@@ -362,12 +607,12 @@ function createSqliteAgentRuntimeStore(config) {
           `).get(input.conversationId, input.inputMessageId);
         if (missing(value))
           return;
-        const row = AdmissionRowSchema.parse(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)),
+          input: AgentMessageSchema.parse(parseJson2(row.input_payload)),
           runId: row.run_id,
           assistantMessageId: row.assistant_message_id
         });
@@ -387,7 +632,7 @@ function createSqliteAgentRuntimeStore(config) {
         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)));
+          `).all(conversationId).map((value) => AgentMessageSchema.parse(parseJson2(MessageRowSchema.parse(value).payload)));
       },
       async apply(transaction, rawMutation) {
         const mutation = AgentHistoryMutationSchema.parse(rawMutation);
@@ -438,6 +683,132 @@ function createSqliteAgentRuntimeStore(config) {
           `).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];
@@ -451,7 +822,7 @@ function createSqliteAgentRuntimeStore(config) {
       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));
+        const run = AgentRunSchema.parse(parseJson2(row.payload));
         return AgentRecoverableDescriptorSchema.parse({
           conversationId: row.conversation_id,
           run
@@ -466,6 +837,17 @@ function createSqliteAgentRuntimeStore(config) {
   };
   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) {
@@ -498,7 +880,7 @@ function createSqliteAgentRuntimeStore(config) {
           if (missing(latestRaw)) {
             throw new Error("Agent conversation head has no active history");
           }
-          const latest = AgentMessageSchema.parse(parseJson(MessagePageRowSchema.parse(latestRaw).payload));
+          const latest = AgentMessageSchema.parse(parseJson2(MessagePageRowSchema.parse(latestRaw).payload));
           const active = CountRowSchema.parse(database.prepare(`
                   SELECT count(*) AS count FROM stitchkit_agent_runtime_runs
                   WHERE conversation_id = ?
@@ -535,7 +917,7 @@ function createSqliteAgentRuntimeStore(config) {
         const ordered = before ? [...pageRows].reverse() : pageRows;
         const boundary = pageRows.at(-1);
         return AgentConversationMessagePageSchema.parse({
-          items: ordered.map((row) => AgentMessageSchema.parse(parseJson(row.payload))),
+          items: ordered.map((row) => AgentMessageSchema.parse(parseJson2(row.payload))),
           ...hasMore && boundary ? { nextCursor: messageCursor(boundary.position) } : {}
         });
       })