stitchkit 0.70.4 → 0.70.6

package/dist/{index-jw81xr75.js → index-19eet1qx.js}

@@ -30,19 +30,49 @@ var AgentConversationMessagePageSchema = z.object({
   nextCursor: z.string().min(1).optional()
 }).strict();
 
-// src/agent-runtime/store.ts
+// src/agent-runtime/purge.ts
 import { z as z2 } from "zod";
-var AgentStoreConflictSchema = z2.object({
-  outcome: z2.literal("conflict"),
+var AgentConversationPurgeInputSchema = z2.strictObject({
+  conversationId: AgentRecordIdSchema,
+  expectedVersion: AgentRecordVersionSchema.optional()
+});
+var AgentConversationPurgeResultSchema = z2.discriminatedUnion("outcome", [
+  z2.strictObject({ outcome: z2.literal("purged") }),
+  z2.strictObject({ outcome: z2.literal("already_purged") }),
+  z2.strictObject({ outcome: z2.literal("unsupported") }),
+  z2.strictObject({
+    outcome: z2.literal("active"),
+    runIds: z2.array(AgentRecordIdSchema).min(1)
+  }),
+  z2.strictObject({ outcome: z2.literal("conflict"), actualVersion: AgentRecordVersionSchema })
+]);
+
+class AgentConversationPurgedError extends Error {
+  constructor() {
+    super("Agent conversation has been purged; use a new conversation ID");
+    this.name = "AgentConversationPurgedError";
+  }
+}
+async function purgeAgentConversation(store, input) {
+  const parsed = AgentConversationPurgeInputSchema.parse(input);
+  if (!store.purgeConversation)
+    return { outcome: "unsupported" };
+  return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
+}
+
+// src/agent-runtime/store.ts
+import { z as z3 } from "zod";
+var AgentStoreConflictSchema = z3.object({
+  outcome: z3.literal("conflict"),
   actualVersion: AgentRecordVersionSchema
 });
-var AgentStoreNotFoundSchema = z2.object({ outcome: z2.literal("not_found") });
-var AgentStoreAppliedSchema = z2.object({
-  outcome: z2.literal("applied"),
+var AgentStoreNotFoundSchema = z3.object({ outcome: z3.literal("not_found") });
+var AgentStoreAppliedSchema = z3.object({
+  outcome: z3.literal("applied"),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreDuplicateSchema = z2.object({
-  outcome: z2.literal("duplicate"),
+var AgentStoreDuplicateSchema = z3.object({
+  outcome: z3.literal("duplicate"),
   input: AgentMessageSchema,
   inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
@@ -51,116 +81,141 @@ var AgentStoreDuplicateSchema = z2.object({
   assistant: AgentMessageSchema.optional(),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreMutationResultSchema = z2.discriminatedUnion("outcome", [
+var AgentStoreMutationResultSchema = z3.discriminatedUnion("outcome", [
   AgentStoreAppliedSchema,
   AgentStoreDuplicateSchema,
   AgentStoreConflictSchema,
   AgentStoreNotFoundSchema
 ]);
-var AgentRunViewSchema = z2.object({
+var AgentRunViewSchema = z3.object({
   snapshotVersion: AgentRecordVersionSchema,
   run: AgentRunSchema,
   assistant: AgentMessageSchema.optional()
 });
-var AcceptInputAndAssignRunSchema = z2.object({
-  idempotencyKey: z2.string().min(1),
+var AcceptInputAndAssignRunSchema = z3.object({
+  idempotencyKey: z3.string().min(1),
   expectedVersion: AgentRecordVersionSchema.optional(),
   input: AgentMessageSchema,
   run: AgentRunSchema,
   coalesceIntoRunId: AgentRecordIdSchema.optional()
 });
-var AcquireAgentRunSchema = z2.object({
+var AcquireAgentRunSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1)
+  ownerId: z3.string().min(1)
 });
-var CheckpointRunAssistantSchema = z2.object({
+var CheckpointRunAssistantSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1),
+  ownerId: z3.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   usage: AgentUsageSchema.optional()
 });
-var CommitRunTerminalSchema = z2.object({
+var CommitRunTerminalSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z2.string().min(1),
+  ownerId: z3.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z2.string().min(1).optional(),
+  policyName: z3.string().min(1).optional(),
   usage: AgentUsageSchema.optional(),
-  absorb: z2.array(z2.object({
+  absorb: z3.array(z3.object({
     runId: AgentRecordIdSchema,
-    inputMessageIds: z2.array(AgentRecordIdSchema).min(1)
+    inputMessageIds: z3.array(AgentRecordIdSchema).min(1)
   })).min(1).optional()
 });
-var RequestRunInterruptSchema = z2.object({
+var RequestRunInterruptSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema
 });
-var RecoverAgentRunSchema = z2.object({
+var RecoverAgentRunSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  action: z2.enum(["requeue", "abandon"]),
-  replaySafe: z2.boolean().optional()
+  action: z3.enum(["requeue", "abandon"]),
+  replaySafe: z3.boolean().optional()
 });
-var ReplaceCompactedRangeSchema = z2.object({
+var ReplaceCompactedRangeSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
+  replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
   summary: AgentMessageSchema
 });
-var AgentRecoverableDescriptorSchema = z2.object({
+var AgentRecoverableDescriptorSchema = z3.object({
   conversationId: AgentRecordIdSchema,
   run: AgentRunSchema
 });
-var AgentRecoverablePageSchema = z2.object({
-  items: z2.array(AgentRecoverableDescriptorSchema),
-  nextCursor: z2.string().min(1).optional()
+var AgentRecoverablePageSchema = z3.object({
+  items: z3.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z3.string().min(1).optional()
 });
 
 // src/agent-runtime/store-driver.ts
-import { z as z3 } from "zod";
-var AgentRuntimeHeadSchema = z3.object({
-  schemaVersion: z3.literal(1),
+import { z as z4 } from "zod";
+
+// src/agent-runtime/store-purge.ts
+function createStoreConversationPurge(driver, conversations) {
+  return async (input) => {
+    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema.parse(input);
+    return driver.transaction(async (transaction) => {
+      if (await conversations.isPurged(transaction, conversationId)) {
+        return { outcome: "already_purged" };
+      }
+      const head = await driver.head.load(transaction, conversationId);
+      const actualVersion = head?.version ?? 0;
+      if (expectedVersion !== undefined && expectedVersion !== actualVersion) {
+        return { outcome: "conflict", actualVersion };
+      }
+      const active = await driver.runs.listActive(transaction, conversationId);
+      if (active.length > 0) {
+        return { outcome: "active", runIds: active.map((record) => record.run.id) };
+      }
+      await conversations.remove(transaction, conversationId);
+      return { outcome: "purged" };
+    });
+  };
+}
+
+// src/agent-runtime/store-driver.ts
+var AgentRuntimeHeadSchema = z4.object({
+  schemaVersion: z4.literal(1),
   conversationId: AgentRecordIdSchema,
   version: AgentRecordVersionSchema
 });
-var AgentStoredRunSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var AgentStoredRunSchema = z4.object({
+  schemaVersion: z4.literal(1),
   run: AgentRunSchema,
   terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentAdmissionReceiptSchema = z3.object({
-  schemaVersion: z3.literal(1),
+var AgentAdmissionReceiptSchema = z4.object({
+  schemaVersion: z4.literal(1),
   conversationId: AgentRecordIdSchema,
-  idempotencyKey: z3.string().min(1),
+  idempotencyKey: z4.string().min(1),
   input: AgentMessageSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema
 });
-var AgentHistoryMutationSchema = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("admit"), input: AgentMessageSchema }),
-  z3.object({
-    type: z3.literal("upsert-assistant"),
+var AgentHistoryMutationSchema = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("admit"), input: AgentMessageSchema }),
+  z4.object({
+    type: z4.literal("upsert-assistant"),
     message: AgentMessageSchema
   }),
-  z3.object({
-    type: z3.literal("replace-compacted-range"),
-    replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
+  z4.object({
+    type: z4.literal("replace-compacted-range"),
+    replacedMessageIds: z4.array(AgentRecordIdSchema).min(1),
     summary: AgentMessageSchema
   })
 ]);
-var AgentRecoverableScanInputSchema = z3.object({
-  cursor: z3.string().min(1).optional(),
-  limit: z3.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z4.object({
+  cursor: z4.string().min(1).optional(),
+  limit: z4.number().int().min(1).max(1000)
 });
 function emptyHead(conversationId) {
   return AgentRuntimeHeadSchema.parse({
@@ -264,7 +319,7 @@ function validateSnapshot(head, messages, records) {
     }
   }
 }
-var RecoverableCursorSchema = z3.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+var RecoverableCursorSchema = z4.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -622,6 +677,9 @@ function createAgentRuntimeStore(driver) {
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
+    if (await driver.conversations?.isPurged(transaction, conversationId)) {
+      throw new AgentConversationPurgedError;
+    }
     const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
     const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
       driver.head.load(transaction, conversationId),
@@ -724,6 +782,9 @@ function createAgentRuntimeStore(driver) {
     loadSnapshot,
     loadRun,
     listActiveRuns,
+    ...driver.conversations && {
+      purgeConversation: createStoreConversationPurge(driver, driver.conversations)
+    },
     acceptInputAndAssignRun: (input) => mutate({
       type: "accept",
       input: AcceptInputAndAssignRunSchema.parse(input)
@@ -768,6 +829,7 @@ function cloneHistoryMap(source) {
   ]));
 }
 function createMemoryAgentRuntimeStore() {
+  let purged = new Set;
   let heads = new Map;
   let runs = new Map;
   let admissions = new Map;
@@ -784,6 +846,7 @@ function createMemoryAgentRuntimeStore() {
         return;
       });
       const transaction = {
+        purged: new Set(purged),
         heads: cloneHeadMap(heads),
         runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
         admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
@@ -791,6 +854,7 @@ function createMemoryAgentRuntimeStore() {
       };
       try {
         const result = await work(transaction);
+        purged = transaction.purged;
         heads = transaction.heads;
         runs = transaction.runs;
         admissions = transaction.admissions;
@@ -800,6 +864,18 @@ function createMemoryAgentRuntimeStore() {
         release.resolve();
       }
     },
+    conversations: {
+      async isPurged(transaction, conversationId) {
+        return transaction.purged.has(conversationId);
+      },
+      async remove(transaction, conversationId) {
+        transaction.purged.add(conversationId);
+        transaction.heads.delete(conversationId);
+        transaction.runs.delete(conversationId);
+        transaction.admissions.delete(conversationId);
+        transaction.histories.delete(conversationId);
+      }
+    },
     head: {
       async load(transaction, conversationId) {
         const head = transaction.heads.get(conversationId);
@@ -912,4 +988,4 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 
-export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };
+export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };

package/dist/{index-7wpgrqa8.js → index-3z73fh2c.js}

@@ -1,5 +1,84 @@
 // src/server/shutdown.ts
 import { z } from "zod";
+
+// src/server/http-stream-lifetime.ts
+var requests = new WeakMap;
+function isStreamCancellation(error, signal) {
+  return signal.aborted && (error === signal.reason || error instanceof Error && error.name === "AbortError" && error.cause === signal.reason);
+}
+function ownHttpStream(request, stream) {
+  requests.get(request)?.add(stream);
+}
+async function settleStreamCleanup(operations) {
+  const results = await Promise.allSettled(operations);
+  const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (errors.length)
+    throw new AggregateError(errors, "HTTP stream source did not close cleanly");
+}
+function createHttpStreamTracker() {
+  const streams = new Map;
+  const failures = [];
+  let draining = false;
+  const assertClean = () => {
+    if (failures.length) {
+      throw new AggregateError(failures, "[stitchkit] HTTP stream cleanup failed");
+    }
+  };
+  return {
+    bind(request, onComplete) {
+      let handlerDone = false;
+      let pending = 0;
+      const complete = () => {
+        if (!handlerDone || pending !== 0)
+          return;
+        requests.delete(request);
+        onComplete();
+      };
+      requests.set(request, {
+        add(stream) {
+          pending += 1;
+          streams.set(stream, request);
+          stream.settled.then(() => {
+            streams.delete(stream);
+            pending -= 1;
+            complete();
+          }, (error) => {
+            if (draining)
+              failures.push(error);
+            else
+              console.error("[stitchkit] HTTP stream cleanup failed:", error);
+            streams.delete(stream);
+            pending -= 1;
+            complete();
+          });
+          if (draining)
+            stream.cancel();
+        }
+      });
+      return () => {
+        handlerDone = true;
+        complete();
+      };
+    },
+    get pendingRequests() {
+      return new Set(streams.values()).size;
+    },
+    cancel() {
+      draining = true;
+      for (const stream of streams.keys())
+        stream.cancel();
+    },
+    assertClean,
+    async drain() {
+      while (streams.size) {
+        await Promise.allSettled([...streams.keys()].map((stream) => stream.settled));
+      }
+      assertClean();
+    }
+  };
+}
+
+// src/server/shutdown.ts
 var ShutdownStateSchema = z.enum([
   "running",
   "draining-http",
@@ -109,13 +188,15 @@ function createServerLifecycle(getAdapter) {
   let pendingApplicationRequests = 0;
   let retryAfterSeconds = 5;
   let shutdownPromise;
+  const streams = createHttpStreamTracker();
+  const pendingRequests = () => Math.max(getAdapter().pendingRequests(), streams.pendingRequests);
   const status = () => {
     const adapter = getAdapter();
     return ShutdownStatusSchema.parse({
       state,
       acceptedRequests,
       completedRequests,
-      pendingRequests: adapter.pendingRequests(),
+      pendingRequests: pendingRequests(),
       pendingWebSockets: adapter.pendingWebSockets()
     });
   };
@@ -125,11 +206,14 @@ function createServerLifecycle(getAdapter) {
         return rejectedResponse(retryAfterSeconds);
       acceptedRequests += 1;
       pendingApplicationRequests += 1;
+      const complete = streams.bind(request, () => {
+        completedRequests += 1;
+      });
       try {
         return await handler(request, server);
       } finally {
         pendingApplicationRequests -= 1;
-        completedRequests += 1;
+        complete();
       }
     };
   };
@@ -142,6 +226,7 @@ function createServerLifecycle(getAdapter) {
     const adapter = getAdapter();
     state = "draining-http";
     adapter.beginShutdown(retryAfterSeconds);
+    streams.cancel();
     shutdownPromise = new Promise((resolve, reject) => {
       const phaseAbort = new AbortController;
       let forcedReason;
@@ -164,7 +249,8 @@ function createServerLifecycle(getAdapter) {
       };
       (async () => {
         try {
-          await waitForZero(() => pendingApplicationRequests, phaseAbort.signal);
+          await waitForZero(() => pendingApplicationRequests + streams.pendingRequests, phaseAbort.signal);
+          streams.assertClean();
           if (!forcedReason) {
             state = "closing-realtime";
             const realtimeOutcome = await closeRealtimeWithin(adapter, parsed.realtimeCloseTimeoutMs, phaseAbort.signal);
@@ -189,13 +275,13 @@ function createServerLifecycle(getAdapter) {
         let pendingWebSocketsAtForce = 0;
         if (forcedReason) {
           state = "stopping-runtime";
-          pendingRequestsAtForce = adapter.pendingRequests();
+          pendingRequestsAtForce = pendingRequests();
           pendingWebSocketsAtForce = adapter.pendingWebSockets();
           forcedWebSockets += pendingWebSocketsAtForce;
           let forceError;
           let forceFailed = false;
           try {
-            await withTimeout(adapter.forceStop(), parsed.forceTimeoutMs, `[stitchkit] forced shutdown did not complete within ${parsed.forceTimeoutMs}ms`);
+            await withTimeout(Promise.all([adapter.forceStop(), streams.drain()]), parsed.forceTimeoutMs, `[stitchkit] forced shutdown did not complete within ${parsed.forceTimeoutMs}ms`);
           } catch (error) {
             forceFailed = true;
             forceError = error;
@@ -219,7 +305,7 @@ function createServerLifecycle(getAdapter) {
           ...forcedReason && { reason: forcedReason },
           acceptedRequests,
           completedRequests,
-          pendingRequests: adapter.pendingRequests(),
+          pendingRequests: pendingRequests(),
           pendingWebSockets: adapter.pendingWebSockets(),
           pendingRequestsAtForce,
           pendingWebSocketsAtForce,
@@ -243,4 +329,4 @@ function createServerLifecycle(getAdapter) {
   };
 }
 
-export { ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle };
+export { isStreamCancellation, ownHttpStream, settleStreamCleanup, ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle };

package/dist/{index-35wcrke5.js → index-by57nwhc.js}

@@ -2182,6 +2182,9 @@ function createAgentRuntime(config) {
         updatedAt: nowIso
       });
       const outerAccepted = Promise.withResolvers();
+      outerAccepted.promise.catch(() => {
+        return;
+      });
       const outerAdmission = Promise.withResolvers();
       outerAdmission.promise.catch(() => {
         return;

package/dist/{index-9sx8tbz2.js → index-cksjz4eg.js}

@@ -8,7 +8,7 @@ import {
   AgentRuntimeHeadSchema,
   AgentStoredRunSchema,
   createAgentRuntimeStore
-} from "./index-jw81xr75.js";
+} from "./index-19eet1qx.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
@@ -16,6 +16,52 @@ import {
 
 // src/agent-runtime/sqlite.ts
 import { z } from "zod";
+
+// src/agent-runtime/sqlite-purge.ts
+var OWNED_TABLES = [
+  "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);
+      }
+    }
+  };
+}
+
+// src/agent-runtime/sqlite.ts
 var HeadRowSchema = z.object({ version: z.number().int().nonnegative() });
 var RunRowSchema = z.object({
   payload: z.string(),
@@ -121,6 +167,7 @@ function initializeAgentRuntimeSqlite(database) {
       if (missingTables.length > 0) {
         throw new Error(`Refusing a partial Stitchkit agent-runtime SQLite schema; missing ${missingTables.join(", ")}`);
       }
+      initializeSqliteConversationPurge(database);
       database.exec("COMMIT");
       return;
     }
@@ -165,6 +212,7 @@ function initializeAgentRuntimeSqlite(database) {
       );
       INSERT INTO stitchkit_agent_runtime_meta (key, value) VALUES ('schema_version', '1');
     `);
+    initializeSqliteConversationPurge(database);
     database.exec("COMMIT");
   } catch (error) {
     database.exec("ROLLBACK");
@@ -197,6 +245,7 @@ function createSqliteAgentRuntimeStore(config) {
     return result;
   };
   const driver = {
+    conversations: sqliteConversationPurge(database),
     transaction: (work) => serial(async () => {
       database.exec("BEGIN IMMEDIATE");
       try {