stitchkit 0.110.0 → 0.110.2

package/dist/{index-jyw90rps.js → index-bm180f2d.js}

@@ -4,17 +4,10 @@ import {
 import {
   NativeCommandError2
 } from "./index-84bf5spd.js";
-import {
-  probeAgentProcessSandboxOutcome,
-  missingSandboxRestrictions2,
-  codingRefusal,
-  codingPathRefusal,
-  refuseMissingCodingPath
-} from "./index-8ks9b85e.js";
 import {
   CommandStopped,
   startNativeCommand
-} from "./index-7a1xhhdx.js";
+} from "./index-e1sjcjfy.js";
 import {
   NumericFileHandle,
   descriptorPath,
@@ -36,8 +29,10 @@ import {
   defineRuntimeTool2
 } from "./index-636mggad.js";
 import {
+  AppError2,
   forbidden2,
-  conflict2
+  conflict2,
+  STITCH_ERROR_STATUS2
 } from "./index-j9gxbztg.js";
 
 // src/agent-runtime/coding-tool-contract.ts
@@ -183,9 +178,80 @@ function resolveCodingToolLimits(input) {
   return AgentCodingToolLimitsSchema2.parse({ ...DEFAULT_LIMITS, ...input });
 }
 
+// src/agent-runtime/sandbox.ts
+import { z as z2 } from "zod";
+var AgentSandboxRestrictionSchema2 = z2.enum([
+  "network-denied",
+  "write-contained",
+  "secrets-hidden",
+  "process-contained"
+]);
+var AgentSandboxGradeSchema2 = z2.discriminatedUnion("grade", [
+  z2.object({ grade: z2.literal("full"), restrictions: z2.array(AgentSandboxRestrictionSchema2) }).strict(),
+  z2.object({
+    grade: z2.literal("partial"),
+    restrictions: z2.array(AgentSandboxRestrictionSchema2),
+    gaps: z2.array(AgentSandboxRestrictionSchema2)
+  }).strict(),
+  z2.object({ grade: z2.literal("unavailable"), reason: z2.string().min(1) }).strict()
+]);
+var probes = new WeakMap;
+var PROBE_FAILED = "sandbox probe failed";
+var PROBE_INVALID = "sandbox probe returned no valid grade";
+async function runProbe(sandbox) {
+  let value;
+  try {
+    value = await sandbox.probe();
+  } catch (cause) {
+    return { grade: { grade: "unavailable", reason: PROBE_FAILED }, cause };
+  }
+  const parsed = AgentSandboxGradeSchema2.safeParse(value);
+  if (parsed.success)
+    return { grade: parsed.data };
+  return { grade: { grade: "unavailable", reason: PROBE_INVALID }, cause: parsed.error };
+}
+function probeAgentProcessSandboxOutcome(sandbox, options = {}) {
+  if (options.refresh)
+    probes.delete(sandbox);
+  const present = probes.get(sandbox);
+  if (present)
+    return present;
+  const pending = runProbe(sandbox);
+  probes.set(sandbox, pending);
+  return pending;
+}
+async function probeAgentProcessSandbox2(sandbox, options = {}) {
+  const fresh = options.refresh === true || !probes.has(sandbox);
+  const outcome = await probeAgentProcessSandboxOutcome(sandbox, options);
+  if (fresh && outcome.cause !== undefined) {
+    process.emitWarning(new Error("Sandbox probe failed", { cause: outcome.cause }));
+  }
+  return outcome.grade;
+}
+function missingSandboxRestrictions2(grade, required) {
+  if (grade.grade === "unavailable")
+    return required;
+  const present = new Set(grade.restrictions);
+  return required.filter((restriction) => !present.has(restriction));
+}
+async function recordAgentSandboxProbe2(input) {
+  const grade = await probeAgentProcessSandbox2(input.sandbox);
+  const missing = missingSandboxRestrictions2(grade, input.required);
+  await input.store.appendEvent({
+    conversationId: input.conversationId,
+    kind: "sandbox/probed",
+    payload: {
+      result: grade,
+      required: [...input.required],
+      missing: [...missing]
+    }
+  });
+  return grade;
+}
+
 // src/agent-runtime/coding-tools.ts
 import path5 from "node:path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/agent-runtime/coding-tool-files.ts
 import { createHash } from "node:crypto";
@@ -194,6 +260,60 @@ import { realpath as realpath2 } from "node:fs/promises";
 // src/agent-runtime/coding-tool-paths.ts
 import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
+
+// src/agent-runtime/coding-tool-refusals.ts
+function codingRefusal(code, message, options = {}) {
+  throw new AppError2(code, {
+    message,
+    status: STITCH_ERROR_STATUS2[code],
+    details: { message, ...options.details },
+    hint: options.hint,
+    ..."cause" in options && { cause: options.cause }
+  });
+}
+function codingPathRefusal(code, message, path, options = {}) {
+  codingRefusal(code, message, {
+    details: { path, ...options.details },
+    ...options.hint && { hint: options.hint }
+  });
+}
+function refuseMissingCodingPath(error, relative) {
+  const code = error?.code;
+  if (error instanceof Error && error.message.includes("is not a regular file")) {
+    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+      hint: "Use list_directory to see what is here."
+    });
+  }
+  if (code === "ENOENT") {
+    codingPathRefusal("NOT_FOUND", "This path does not exist", relative, {
+      hint: "Use list_directory or glob to find the right path."
+    });
+  }
+  if (code === "ENOTDIR") {
+    codingPathRefusal("BAD_REQUEST", "A segment of this path is not a directory", relative, {
+      hint: "Check the path with list_directory."
+    });
+  }
+  if (code === "ELOOP") {
+    codingPathRefusal("FORBIDDEN", "This path is a symlink, which is not followed", relative, {
+      hint: "Read or write the target directly, by its own workspace-relative path."
+    });
+  }
+  if (code === "EISDIR") {
+    codingPathRefusal("BAD_REQUEST", "This path is not a regular file", relative, {
+      hint: "Use list_directory to see what is here."
+    });
+  }
+  throw error;
+}
+function refuseUnknownSpillReference(reference) {
+  codingRefusal("SPILL_REFERENCE_UNKNOWN", `No spilled output is held under \`${reference}\``, {
+    details: { reference },
+    hint: "Use the reference returned by the command that spilled its output, not a session or call id."
+  });
+}
+
+// src/agent-runtime/coding-tool-paths.ts
 function within(root, target) {
   const relative = path.relative(root, target);
   return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
@@ -579,7 +699,7 @@ function createFileCodingTools(config, limits) {
 // src/agent-runtime/coding-tool-listing.ts
 import { realpath as realpath3 } from "node:fs/promises";
 import path3 from "node:path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var DEFAULT_EXCLUDED_DIRECTORIES = [
   ".git",
   ".next",
@@ -589,28 +709,28 @@ var DEFAULT_EXCLUDED_DIRECTORIES = [
   "dist",
   "node_modules"
 ];
-var ListInputSchema = z2.object({ path: z2.string().min(1).default(".") }).strict();
-var ListOutputSchema = z2.object({
-  path: z2.string().min(1),
-  entries: z2.array(z2.object({
-    name: z2.string().min(1),
-    kind: z2.enum(["file", "directory", "symlink", "other"]),
-    bytes: z2.int().nonnegative().optional(),
-    excluded: z2.boolean().optional()
+var ListInputSchema = z3.object({ path: z3.string().min(1).default(".") }).strict();
+var ListOutputSchema = z3.object({
+  path: z3.string().min(1),
+  entries: z3.array(z3.object({
+    name: z3.string().min(1),
+    kind: z3.enum(["file", "directory", "symlink", "other"]),
+    bytes: z3.int().nonnegative().optional(),
+    excluded: z3.boolean().optional()
   }).strict()),
-  truncated: z2.boolean(),
-  denied: z2.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z2.boolean().optional()
+  truncated: z3.boolean(),
+  denied: z3.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z3.boolean().optional()
 }).strict();
-var GlobInputSchema = z2.object({ pattern: z2.string().min(1), path: z2.string().min(1).default(".") }).strict();
-var GlobOutputSchema = z2.object({
-  paths: z2.array(z2.string().min(1)),
-  truncated: z2.boolean(),
-  resultTruncated: z2.boolean(),
-  skippedDirectories: z2.int().nonnegative(),
-  scannedFiles: z2.int().nonnegative(),
-  denied: z2.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z2.boolean().optional()
+var GlobInputSchema = z3.object({ pattern: z3.string().min(1), path: z3.string().min(1).default(".") }).strict();
+var GlobOutputSchema = z3.object({
+  paths: z3.array(z3.string().min(1)),
+  truncated: z3.boolean(),
+  resultTruncated: z3.boolean(),
+  skippedDirectories: z3.int().nonnegative(),
+  scannedFiles: z3.int().nonnegative(),
+  denied: z3.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z3.boolean().optional()
 }).strict();
 function compileWorkspaceGlob(pattern) {
   let source = "";
@@ -743,29 +863,29 @@ function createListingCodingTools(config, limits) {
 import { createHash as createHash2 } from "node:crypto";
 import { realpath as realpath4 } from "node:fs/promises";
 import path4 from "node:path";
-import { z as z3 } from "zod";
-var SearchInputSchema = z3.object({
-  query: z3.string().min(1),
-  mode: z3.enum(["path", "content"]).default("content"),
-  regex: z3.boolean().default(false),
-  context: z3.int().nonnegative().max(10).default(0),
-  include: z3.string().min(1).describe("Anchored `**`/`*`/`?` pattern matched against the whole workspace-relative path. `*` does not cross `/`; use `**/` to include matching files in subdirectories.").optional()
+import { z as z4 } from "zod";
+var SearchInputSchema = z4.object({
+  query: z4.string().min(1),
+  mode: z4.enum(["path", "content"]).default("content"),
+  regex: z4.boolean().default(false),
+  context: z4.int().nonnegative().max(10).default(0),
+  include: z4.string().min(1).describe("Anchored `**`/`*`/`?` pattern matched against the whole workspace-relative path. `*` does not cross `/`; use `**/` to include matching files in subdirectories.").optional()
 }).strict();
-var SearchOutputSchema = z3.object({
-  matches: z3.array(z3.object({
-    path: z3.string().min(1),
-    line: z3.int().positive().optional(),
-    text: z3.string().optional(),
-    before: z3.array(z3.string()).optional(),
-    after: z3.array(z3.string()).optional()
+var SearchOutputSchema = z4.object({
+  matches: z4.array(z4.object({
+    path: z4.string().min(1),
+    line: z4.int().positive().optional(),
+    text: z4.string().optional(),
+    before: z4.array(z4.string()).optional(),
+    after: z4.array(z4.string()).optional()
   }).strict()),
-  truncated: z3.boolean(),
-  scannedFiles: z3.int().nonnegative().describe("Files admitted by include and host authorization that reached path or content comparison."),
-  skippedDirectories: z3.int().nonnegative(),
-  skippedSymlinks: z3.int().nonnegative(),
-  denied: z3.array(CodingDeniedEntrySchema).optional(),
-  deniedTruncated: z3.boolean().optional(),
-  hint: z3.string().min(1).optional()
+  truncated: z4.boolean(),
+  scannedFiles: z4.int().nonnegative().describe("Files admitted by include and host authorization that reached path or content comparison."),
+  skippedDirectories: z4.int().nonnegative(),
+  skippedSymlinks: z4.int().nonnegative(),
+  denied: z4.array(CodingDeniedEntrySchema).optional(),
+  deniedTruncated: z4.boolean().optional(),
+  hint: z4.string().min(1).optional()
 }).strict();
 function compileSearchRegex(pattern) {
   if (/\\[1-9]/.test(pattern) || /\(\?<?[=!]/.test(pattern)) {
@@ -784,21 +904,21 @@ function compileSearchRegex(pattern) {
   }
 }
 var MAX_SEARCHED_LINE_BYTES = 8192;
-var EditInputSchema = z3.object({
-  path: z3.string().min(1),
-  oldText: z3.string().min(1),
-  newText: z3.string(),
-  replaceAll: z3.boolean().default(false),
-  expectedSha256: z3.string().length(64).optional(),
-  dryRun: z3.boolean().default(false)
+var EditInputSchema = z4.object({
+  path: z4.string().min(1),
+  oldText: z4.string().min(1),
+  newText: z4.string(),
+  replaceAll: z4.boolean().default(false),
+  expectedSha256: z4.string().length(64).optional(),
+  dryRun: z4.boolean().default(false)
 }).strict();
-var EditOutputSchema = z3.object({
-  path: z3.string().min(1),
-  baseSha256: z3.string().length(64),
-  sha256: z3.string().length(64),
-  replacements: z3.int().positive(),
-  bytes: z3.int().nonnegative(),
-  applied: z3.boolean()
+var EditOutputSchema = z4.object({
+  path: z4.string().min(1),
+  baseSha256: z4.string().length(64),
+  sha256: z4.string().length(64),
+  replacements: z4.int().positive(),
+  bytes: z4.int().nonnegative(),
+  applied: z4.boolean()
 }).strict();
 function sha256(value) {
   return createHash2("sha256").update(value).digest("hex");
@@ -1278,17 +1398,17 @@ function createAgentCodingTools2(config) {
       name: AGENT_CODING_TOOL_NAMES.readOutput,
       description: "Read a bounded byte slice from one opaque coding output artifact.",
       identity: { serviceName: "coding", action: "read-artifact", method: "POST" },
-      input: z4.object({
-        reference: z4.string().min(1),
-        offset: z4.int().nonnegative().default(0),
-        maxBytes: z4.int().positive().optional()
+      input: z5.object({
+        reference: z5.string().min(1),
+        offset: z5.int().nonnegative().default(0),
+        maxBytes: z5.int().positive().optional()
       }).strict(),
-      output: z4.object({
-        reference: z4.string().min(1),
-        offset: z4.int().nonnegative(),
-        text: z4.string(),
-        bytes: z4.int().nonnegative(),
-        totalBytes: z4.int().nonnegative().optional()
+      output: z5.object({
+        reference: z5.string().min(1),
+        offset: z5.int().nonnegative(),
+        text: z5.string(),
+        bytes: z5.int().nonnegative(),
+        totalBytes: z5.int().nonnegative().optional()
       }).strict(),
       transports: ["AGENT"],
       handler: async ({ input }) => {
@@ -1327,14 +1447,14 @@ function createAgentCodingTools2(config) {
         name: AGENT_CODING_TOOL_NAMES.searchOutput,
         description: "Search a durable spilled output without loading it into context.",
         identity: { serviceName: "coding", action: "search-artifact", method: "POST" },
-        input: z4.object({
-          reference: z4.string().min(1),
-          query: z4.string().min(1),
-          maxMatches: z4.int().positive().max(limits.maxSearchResults).default(20)
+        input: z5.object({
+          reference: z5.string().min(1),
+          query: z5.string().min(1),
+          maxMatches: z5.int().positive().max(limits.maxSearchResults).default(20)
         }).strict(),
-        output: z4.object({
-          reference: z4.string(),
-          matches: z4.array(z4.object({ line: z4.int().positive(), text: z4.string() }))
+        output: z5.object({
+          reference: z5.string(),
+          matches: z5.array(z5.object({ line: z5.int().positive(), text: z5.string() }))
         }).strict(),
         transports: ["AGENT"],
         handler: async ({ input }) => {
@@ -1371,4 +1491,4 @@ function createAgentCodingTools2(config) {
   ];
 }
 
-export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, createAgentCodingTools2 };
+export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, ShellOutputSchema, AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, refuseUnknownSpillReference, AGENT_CODING_TOOL_NAMES, createAgentCodingTools2 };

package/dist/{index-mnhtbqrb.js → index-dd1z5kxb.js}

@@ -3,11 +3,11 @@ import {
 } from "./index-q6crhe1n.js";
 import {
   toolErrorFromResult
-} from "./index-73cz22ds.js";
+} from "./index-mha6b4vk.js";
 import {
   collectTools2,
   createToolRunner
-} from "./index-p6mvqcbq.js";
+} from "./index-ghwntn9n.js";
 import {
   AppError2
 } from "./index-j9gxbztg.js";

package/dist/{index-7a1xhhdx.js → index-e1sjcjfy.js}

@@ -23,6 +23,22 @@ import {
   assertPositiveSafeInteger
 } from "./index-0s4xebbg.js";
 
+// src/process/group-presence.ts
+function processGroupExists(pid) {
+  try {
+    process.kill(-pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error) {
+      if (error.code === "ESRCH")
+        return false;
+      if (process.platform === "darwin" && error.code === "EPERM")
+        return true;
+    }
+    throw error;
+  }
+}
+
 // src/process/group-settlement.ts
 import { execFile } from "node:child_process";
 function hasLiveGroupMember(table, group) {
@@ -50,13 +66,26 @@ function processGroups(timeoutMs) {
 async function waitForProcessGroupExit(pid, deadline) {
   if (pid === undefined)
     return;
+  let observations = 0;
+  let lastStates = [];
   for (;; ) {
     const remaining = Math.ceil(deadline - performance.now());
     if (remaining <= 0)
-      throw new Error("Command process group remained alive after SIGKILL");
+      throw new Error("Command process group settlement was not confirmed after SIGKILL", {
+        cause: { groupId: pid, observations, lastStates }
+      });
+    if (!processGroupExists(pid))
+      return;
     const table = await processGroups(remaining);
+    observations++;
     if (!hasLiveGroupMember(table, pid))
       return;
+    lastStates = table.split(/\r?\n/).flatMap((row) => {
+      const fields = /^\s*(\d+)\s+(\S+)\s*$/.exec(row);
+      return Number(fields?.[1]) === pid ? [fields?.[2] ?? "unknown"] : [];
+    }).slice(0, 16);
+    if (!processGroupExists(pid))
+      return;
     await sleep(Math.min(5, Math.max(0, deadline - performance.now())));
   }
 }
@@ -104,16 +133,7 @@ function signalGroup(pid, signal) {
 function exists(pid) {
   if (pid === undefined)
     return false;
-  try {
-    process.kill(-pid, 0);
-    return true;
-  } catch (error) {
-    if (isErrno(error, "ESRCH"))
-      return false;
-    if (deniedOnDarwin(error))
-      return true;
-    throw error;
-  }
+  return processGroupExists(pid);
 }
 async function signalUntilSettled(pid, signal, deadline) {
   for (;; ) {

package/dist/{index-5p55xreg.js → index-e9rbhw1s.js}

@@ -2,7 +2,7 @@ import {
   AgentStoreEventEnvelopeSchema2,
   AgentStoreEventPageSchema2,
   AgentRecoverablePageSchema2
-} from "./index-0gs4ymfj.js";
+} from "./index-6qeqdz0z.js";
 import {
   AgentRecordIdSchema2,
   AgentMessageSchema2
@@ -15,12 +15,64 @@ import {
   AgentHistoryMutationSchema2,
   isActiveRunState,
   replaceMessage,
+  ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-d2h99n7d.js";
+} from "./index-s2bgwsyr.js";
 
 // src/agent-runtime/store-memory.ts
+import { z as z2 } from "zod";
+
+// src/agent-runtime/store-memory-archive.ts
 import { z } from "zod";
-var RecoverableCursorSchema = z.tuple([AgentRecordIdSchema2, AgentRecordIdSchema2]);
+var memoryArchive = {
+  async export(transaction, conversationId) {
+    return {
+      projections: [],
+      spills: z.array(z.json()).parse(structuredClone(transaction.spills.get(conversationId) ?? []))
+    };
+  },
+  async import(transaction, archive) {
+    const spills = archive.spills.map((value) => ArchiveSpillSchema.parse(value));
+    const occupied = new Set([...transaction.spills.values()].flatMap((entries) => entries.map((spill) => spill.reference)));
+    for (const spill of spills) {
+      if (occupied.has(spill.reference))
+        throw new TypeError("Conversation archive spill identity is already present");
+      occupied.add(spill.reference);
+    }
+    transaction.spills.set(archive.conversationId, structuredClone(spills));
+  }
+};
+
+// src/agent-runtime/store-memory-events.ts
+var memoryEvents = {
+  async append(transaction, draft) {
+    const current = transaction.events.get(draft.conversationId) ?? [];
+    const event = AgentStoreEventEnvelopeSchema2.parse({
+      ...draft,
+      seq: (current.at(-1)?.seq ?? 0) + 1
+    });
+    if (current.some((candidate) => candidate.eventId === event.eventId)) {
+      throw new TypeError("Agent store event identity is already present");
+    }
+    transaction.events.set(draft.conversationId, [...current, event]);
+    return event;
+  },
+  async list(transaction, input) {
+    const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
+    const items = selected.slice(0, input.limit);
+    const last = items.at(-1);
+    return AgentStoreEventPageSchema2.parse({
+      items,
+      ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
+    });
+  },
+  async find(transaction, input) {
+    return (transaction.events.get(input.conversationId) ?? []).find((event) => event.eventId === input.eventId);
+  }
+};
+
+// src/agent-runtime/store-memory.ts
+var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema2, AgentRecordIdSchema2]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -46,6 +98,9 @@ function cloneHistoryMap(source) {
   ]));
 }
 var memoryConversations = {
+  async isEmpty(transaction, id) {
+    return !transaction.heads.has(id) && !transaction.runs.has(id) && !transaction.admissions.has(id) && !transaction.seeds.has(id) && !transaction.histories.has(id) && !transaction.events.has(id) && !transaction.spills.has(id);
+  },
   async isPurged(transaction, conversationId) {
     return transaction.purged.has(conversationId);
   },
@@ -57,6 +112,7 @@ var memoryConversations = {
     transaction.seeds.delete(conversationId);
     transaction.histories.delete(conversationId);
     transaction.events.delete(conversationId);
+    transaction.spills.delete(conversationId);
   }
 };
 var memoryHead = {
@@ -140,6 +196,10 @@ var memorySeeds = {
   }
 };
 var memoryHistory = {
+  async restore(transaction, input) {
+    const compacted = new Set(input.compactedMessageIds);
+    transaction.histories.set(input.conversationId, input.messages.filter((message) => !compacted.has(message.id)).map((message) => AgentMessageSchema2.parse(structuredClone(message))));
+  },
   async load(transaction, conversationId) {
     return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema2.parse(structuredClone(message)));
   },
@@ -181,32 +241,6 @@ var memoryHistory = {
     ]);
   }
 };
-var memoryEvents = {
-  async append(transaction, draft) {
-    const current = transaction.events.get(draft.conversationId) ?? [];
-    const event = AgentStoreEventEnvelopeSchema2.parse({
-      ...draft,
-      seq: (current.at(-1)?.seq ?? 0) + 1
-    });
-    if (current.some((candidate) => candidate.eventId === event.eventId)) {
-      throw new TypeError("Agent store event identity is already present");
-    }
-    transaction.events.set(draft.conversationId, [...current, event]);
-    return event;
-  },
-  async list(transaction, input) {
-    const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
-    const items = selected.slice(0, input.limit);
-    const last = items.at(-1);
-    return AgentStoreEventPageSchema2.parse({
-      items,
-      ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
-    });
-  },
-  async find(transaction, input) {
-    return (transaction.events.get(input.conversationId) ?? []).find((event) => event.eventId === input.eventId);
-  }
-};
 function scanMemoryRecoverable(runs, input) {
   const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
   const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
@@ -230,6 +264,7 @@ function createMemoryAgentRuntimeStore2() {
   let seeds = new Map;
   let histories = new Map;
   let events = new Map;
+  let spills = new Map;
   let transactionTail = Promise.resolve();
   const driver = {
     async transaction(work) {
@@ -243,6 +278,7 @@ function createMemoryAgentRuntimeStore2() {
       });
       const transaction = {
         purged: new Set(purged),
+        spills: structuredClone(spills),
         heads: cloneHeadMap(heads),
         runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema2.parse(structuredClone(record))),
         admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema2.parse(structuredClone(receipt))),
@@ -256,6 +292,7 @@ function createMemoryAgentRuntimeStore2() {
       try {
         const result = await work(transaction);
         purged = transaction.purged;
+        spills = transaction.spills;
         heads = transaction.heads;
         runs = transaction.runs;
         admissions = transaction.admissions;
@@ -274,6 +311,7 @@ function createMemoryAgentRuntimeStore2() {
     seeds: memorySeeds,
     history: memoryHistory,
     events: memoryEvents,
+    archive: memoryArchive,
     async scanRecoverable(input) {
       return scanMemoryRecoverable(runs, input);
     }

package/dist/{index-p6mvqcbq.js → index-ghwntn9n.js}

@@ -7,7 +7,7 @@ import {
 import {
   toolErrorFromResult,
   executeToolMethod
-} from "./index-73cz22ds.js";
+} from "./index-mha6b4vk.js";
 import {
   isRetryableStatus2
 } from "./index-j9gxbztg.js";