stitchkit 0.110.1 → 0.110.3

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

@@ -4,13 +4,6 @@ import {
 import {
   NativeCommandError2
 } from "./index-84bf5spd.js";
-import {
-  probeAgentProcessSandboxOutcome,
-  missingSandboxRestrictions2,
-  codingRefusal,
-  codingPathRefusal,
-  refuseMissingCodingPath
-} from "./index-8ks9b85e.js";
 import {
   CommandStopped,
   startNativeCommand
@@ -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-924500c3.js → index-ddkwkcvn.js}

@@ -22,7 +22,7 @@ import {
   createLocalStepDurability2,
   isAgentToolError2,
   createToolDurabilityContext
-} from "./index-c17xcx4k.js";
+} from "./index-56yx8dxp.js";
 import {
   canonicalAgentJson2,
   createToolChronology,
@@ -31,7 +31,7 @@ import {
   isAssistantHistoryEvidence2,
   isCompleteAgentHistoryTurn,
   assistantStatus
-} from "./index-0gs4ymfj.js";
+} from "./index-4fgg1507.js";
 import {
   messageOf
 } from "./index-g149e9pk.js";

package/dist/{index-c0hffcmj.js → index-dgfah0g8.js}

@@ -5,7 +5,7 @@ import {
   AgentRecoverableDescriptorSchema2,
   AgentRecoverablePageSchema2,
   canonicalAgentJson2
-} from "./index-0gs4ymfj.js";
+} from "./index-4fgg1507.js";
 import {
   AgentMessageSchema2,
   AgentRunSchema2
@@ -17,8 +17,9 @@ import {
   AgentSeedReceiptSchema2,
   AgentHistoryMutationSchema2,
   appendEventIn,
+  ArchiveProjectionSchema,
   createAgentRuntimeStore2
-} from "./index-d2h99n7d.js";
+} from "./index-j1cwtyk1.js";
 import {
   AgentConversationPageSchema2,
   AgentConversationMessagePageSchema2
@@ -63,6 +64,14 @@ function sqliteConversationPurge(database) {
   if (table === null || table === undefined)
     return;
   return {
+    async isEmpty(transaction, conversationId) {
+      for (const table of OWNED_TABLES) {
+        const row = transaction.prepare(`SELECT 1 FROM ${table} WHERE conversation_id = ? LIMIT 1`).get(conversationId);
+        if (row !== null && row !== undefined)
+          return false;
+      }
+      return transaction.prepare("SELECT 1 FROM stitchkit_agent_runtime_children WHERE parent_conversation_id = ? OR child_conversation_id = ? LIMIT 1").get(conversationId, conversationId) == null;
+    },
     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;
@@ -584,13 +593,7 @@ var sqliteArchive = {
       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);
+      const projection = ArchiveProjectionSchema.parse(raw);
       transaction.prepare(`
           INSERT INTO stitchkit_agent_runtime_projections
             (conversation_id, name, version, upto_seq, payload, updated_at)
@@ -629,6 +632,15 @@ var sqliteArchive = {
 
 // src/agent-runtime/sqlite-history.ts
 var sqliteHistory = {
+  async restore(transaction, input) {
+    const compacted = new Set(input.compactedMessageIds);
+    for (const [position, message] of input.messages.entries()) {
+      if (message.conversationId !== input.conversationId)
+        throw new TypeError("Restored history has a foreign conversation");
+      transaction.prepare(`INSERT INTO stitchkit_agent_runtime_messages
+        (conversation_id, id, position, active, payload) VALUES (?, ?, ?, ?, ?)`).run(input.conversationId, message.id, position, compacted.has(message.id) ? 0 : 1, encodeJson(message));
+    }
+  },
   async load(transaction, conversationId) {
     return transaction.prepare(`
         SELECT payload FROM stitchkit_agent_runtime_messages