stitchkit 0.120.0 → 0.122.0

package/dist/{index-1jwsfkfz.js → index-eeahxwvg.js}

@@ -1,6 +1,6 @@
 import {
   loadDarwinBinding
-} from "./index-2kbysk9s.js";
+} from "./index-m5m9rmvt.js";
 import {
   errnoOf
 } from "./index-jj9228tt.js";
@@ -90,6 +90,12 @@ async function openPinnedDirectory(absolute, options = {}, io = { realpath }) {
   if (process.platform !== "linux" && process.platform !== "darwin") {
     throw new Error("Contained filesystem operations support Linux and macOS only");
   }
+  if (typeof absolute !== "string") {
+    const searchOnly = options.readable === false;
+    if (process.platform === "darwin")
+      return new NumericFileHandle(loadDarwinBinding().reopenDirectory(absolute.fd, searchOnly));
+    return open(`${descriptorPath(absolute)}/.`, directoryFlags(searchOnly));
+  }
   let prefix = path.resolve(absolute);
   const missing = [];
   let canonical;
@@ -131,11 +137,8 @@ async function openPinnedDirectory(absolute, options = {}, io = { realpath }) {
 
 // src/internal/contained-files.ts
 import { constants as constants2 } from "node:fs";
-import { lstat, open as open2, readdir } from "node:fs/promises";
+import { lstat, open as open2, opendir, readdir } from "node:fs/promises";
 import path2 from "node:path";
-function containedEntryKind(entry) {
-  return entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
-}
 function sameIdentity(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
 }
@@ -177,59 +180,48 @@ async function statAt(directory, name) {
     throw error;
   });
 }
-async function listAt(directory) {
+async function listAt(directory, maxEntries, progress) {
+  progress?.check();
   if (process.platform === "darwin") {
-    return loadDarwinBinding().listAt(directory.fd).map(({ name, mode }) => ({ name, ...entryMetadata(mode) }));
+    return loadDarwinBinding().listAt(directory.fd, maxEntries, progress ? (entry) => {
+      if (entry)
+        progress.entry();
+      progress.check();
+    } : undefined).map(({ name, mode }) => ({ name, ...entryMetadata(mode) }));
+  }
+  if (maxEntries !== undefined) {
+    const stream = await opendir(descriptorPath(directory), { bufferSize: 1 });
+    const entries = [];
+    try {
+      while (entries.length < maxEntries) {
+        progress?.check();
+        const entry = await stream.read();
+        if (entry)
+          progress?.entry();
+        progress?.check();
+        if (!entry)
+          break;
+        entries.push(entry);
+      }
+      return entries;
+    } finally {
+      await stream.close();
+    }
   }
   return readdir(descriptorPath(directory), { withFileTypes: true });
 }
-async function listContainedDirectory(root, relative, maxEntries, authorizePath) {
+async function openContainedDirectory(root, relative, beforeOpen) {
   let current = await openPinnedDirectory(root);
   try {
-    if (relative !== ".") {
+    if (relative !== ".")
       for (const segment of safeSegments(relative)) {
+        beforeOpen?.();
         current = await descend(current, await openDirectoryAt(current, segment));
       }
-    }
-    const raw = [...await listAt(current)];
-    raw.sort((left, right) => left.name.localeCompare(right.name));
-    const admitted = [];
-    const denied = [];
-    for (const entry of raw) {
-      const entryPath = relative === "." ? entry.name : path2.join(relative, entry.name);
-      if (authorizePath && !await authorizePath(entryPath)) {
-        denied.push({ name: entry.name, kind: containedEntryKind(entry) });
-        continue;
-      }
-      admitted.push(entry);
-    }
-    const entries = [];
-    for (const entry of admitted.slice(0, maxEntries)) {
-      const kind = containedEntryKind(entry);
-      if (kind !== "file") {
-        entries.push({ name: entry.name, kind });
-        continue;
-      }
-      const metadata = await statAt(current, entry.name);
-      entries.push({
-        name: entry.name,
-        kind,
-        ...metadata && { bytes: metadata.size }
-      });
-    }
-    entries.sort((left, right) => {
-      if (left.kind === right.kind)
-        return left.name.localeCompare(right.name);
-      return left.kind === "directory" ? -1 : right.kind === "directory" ? 1 : 0;
-    });
-    return {
-      entries,
-      truncated: admitted.length > maxEntries,
-      denied: denied.slice(0, maxEntries),
-      deniedTruncated: denied.length > maxEntries
-    };
-  } finally {
+    return current;
+  } catch (error) {
     await current.close();
+    throw error;
   }
 }
 async function missingContainedDirectories(root, relative) {
@@ -265,27 +257,41 @@ function alternateSpellings(name) {
   const swapped = [...name].map((letter) => letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase()).join("");
   return [...new Set([swapped, name.normalize("NFC"), name.normalize("NFD")])].filter((spelling) => spelling !== name);
 }
-async function misspelledContainedSegment(root, relative) {
+async function misspelledContainedSegment(root, relative, progress) {
   const segments = safeSegments(relative);
-  let current = await openPinnedDirectory(root);
+  const wait = (operation, disposeLate) => progress ? progress.wait(operation, disposeLate) : operation();
+  const dispose = (handle) => {
+    handle.close().catch(() => {
+      return;
+    });
+  };
+  let current = await wait(() => openPinnedDirectory(root), dispose);
   try {
     for (const [index, segment] of segments.entries()) {
-      const exists = async (name) => await statAt(current, name).catch(() => null) !== null;
+      progress?.check();
+      const exists = async (name) => await wait(() => statAt(current, name).catch(() => null)) !== null;
       let folded = false;
       for (const spelling of alternateSpellings(segment)) {
         folded ||= await exists(spelling);
       }
       if (folded && await exists(segment)) {
-        const stored = (await listAt(current)).some(({ name }) => name === segment);
+        const maximum = progress?.remainingEntries();
+        const entries = await wait(() => listAt(current, maximum, progress));
+        progress?.remainingEntries();
+        const stored = entries.some(({ name }) => name === segment);
         if (!stored)
           return segment;
       }
       if (index === segments.length - 1)
         return;
-      const next = await openDirectoryAt(current, segment).catch((error) => {
+      progress?.directory();
+      const next = await wait(() => openDirectoryAt(current, segment).catch((error) => {
         if (["ENOENT", "ENOTDIR", "ELOOP"].includes(errnoOf(error) ?? ""))
           return null;
         throw error;
+      }), (handle) => {
+        if (handle)
+          dispose(handle);
       });
       if (!next)
         return;
@@ -395,27 +401,5 @@ async function openContainedParentFile(parent) {
   }
   return handle;
 }
-async function readContainedUtf8Handle(handle, maxBytes) {
-  const metadata = await handle.stat();
-  if (!metadata.isFile())
-    throw new Error("Contained path is not a regular file");
-  if (metadata.size > maxBytes)
-    throw new Error("Contained file exceeds byte budget");
-  const buffer = Buffer.alloc(metadata.size);
-  let offset = 0;
-  while (offset < buffer.byteLength) {
-    const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
-    if (bytesRead === 0)
-      break;
-    offset += bytesRead;
-  }
-  if (offset !== metadata.size)
-    throw new Error("Contained file changed while being read");
-  return {
-    text: new TextDecoder("utf-8", { fatal: true }).decode(buffer),
-    bytes: offset,
-    mode: metadata.mode
-  };
-}
 
-export { descriptorPath, NumericFileHandle, openDirectoryAt, openPinnedDirectory, isSafeEntryName, openFileAt, listAt, listContainedDirectory, missingContainedDirectories, misspelledContainedSegment, UnapprovedContainedDirectoryError, openContainedParent, openContainedFile, ContainedPathChangedError, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle };
+export { descriptorPath, NumericFileHandle, openDirectoryAt, openPinnedDirectory, isSafeEntryName, openFileAt, listAt, openContainedDirectory, missingContainedDirectories, misspelledContainedSegment, UnapprovedContainedDirectoryError, openContainedParent, openContainedFile, ContainedPathChangedError, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile };

package/dist/{index-sb9dr3tq.js → index-eh71zr32.js}

@@ -1,14 +1,14 @@
-// src/tools/durability-context.ts
+// src/tools/runtime-call-context.ts
 var contexts = new WeakMap;
-function createToolDurabilityContext(factory) {
+function createRuntimeToolContext(factory) {
   const context = {};
   contexts.set(context, factory);
   return context;
 }
-function resolveToolDurability(context, callId, signal) {
+function resolveRuntimeToolCall(context, callId, signal) {
   if (typeof context !== "object" || context === null)
     return;
   return contexts.get(context)?.(callId, signal);
 }
 
-export { createToolDurabilityContext, resolveToolDurability };
+export { createRuntimeToolContext, resolveRuntimeToolCall };

package/dist/{index-nyyam9ce.js → index-f6pw75e1.js}

@@ -17,7 +17,7 @@ import {
   replaceMessage,
   ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-yb9n4pgj.js";
+} from "./index-10rg78vf.js";
 
 // src/agent-runtime/store-memory.ts
 import { z as z2 } from "zod";

package/dist/{index-qevqn3d3.js → index-gq3fnq3f.js}

@@ -1,6 +1,6 @@
 import {
   loadDarwinBinding
-} from "./index-2kbysk9s.js";
+} from "./index-m5m9rmvt.js";
 import {
   errnoOf
 } from "./index-jj9228tt.js";

package/dist/{index-bz479f0x.js → index-gtx3eknx.js}

@@ -3,7 +3,7 @@ import {
   ProcessInstanceSchema2,
   readProcessInstance,
   probeProcessOwner2
-} from "./index-qevqn3d3.js";
+} from "./index-gq3fnq3f.js";
 import {
   BoundedFileReadError,
   readBoundedFile

package/dist/{index-mnkk1ffz.js → index-hs76yzt7.js}

@@ -86,6 +86,17 @@ var AgentToolStatusEventSchema2 = EventIdentitySchema.extend({
   input: z.json().optional(),
   output: z.json().optional()
 });
+var AGENT_TOOL_PROGRESS_MESSAGE_MAX2 = 280;
+var AgentToolProgressEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("tool-progress"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  callId: AgentRecordIdSchema2,
+  toolName: z.string().min(1),
+  message: z.string().max(AGENT_TOOL_PROGRESS_MESSAGE_MAX2).optional(),
+  progress: z.number().finite().optional(),
+  total: z.number().finite().optional()
+});
 var AgentTerminalEventSchema2 = EventIdentitySchema.extend({
   type: z.literal("terminal"),
   eventId: AgentRecordIdSchema2,
@@ -106,6 +117,7 @@ var AgentRuntimeEventSchema2 = z.discriminatedUnion("type", [
   AgentRunStateEventSchema2,
   AgentRunOperationEventSchema2,
   AgentToolStatusEventSchema2,
+  AgentToolProgressEventSchema2,
   AgentTerminalEventSchema2
 ]);
 var AgentRuntimeEventCursorSchema2 = z.object({
@@ -147,4 +159,4 @@ function agentDurableEventId2(type, runId, snapshotVersion) {
   return `${runId}:${type}:${snapshotVersion}`;
 }
 
-export { AgentAdmissionEventSchema2, AgentTransientDeltaEventSchema2, AgentReasoningStartEventSchema2, AgentReasoningDeltaEventSchema2, AgentReasoningEndEventSchema2, AgentAttemptResetEventSchema2, AgentCheckpointEventSchema2, AgentRunStateEventSchema2, AgentRunOperationEventSchema2, AgentToolStatusEventSchema2, AgentTerminalEventSchema2, AgentRuntimeEventSchema2, AgentRuntimeEventCursorSchema2, advanceAgentRuntimeEventCursor2, agentDurableEventId2 };
+export { AgentAdmissionEventSchema2, AgentTransientDeltaEventSchema2, AgentReasoningStartEventSchema2, AgentReasoningDeltaEventSchema2, AgentReasoningEndEventSchema2, AgentAttemptResetEventSchema2, AgentCheckpointEventSchema2, AgentRunStateEventSchema2, AgentRunOperationEventSchema2, AgentToolStatusEventSchema2, AGENT_TOOL_PROGRESS_MESSAGE_MAX2, AgentToolProgressEventSchema2, AgentTerminalEventSchema2, AgentRuntimeEventSchema2, AgentRuntimeEventCursorSchema2, advanceAgentRuntimeEventCursor2, agentDurableEventId2 };

package/dist/{index-nn9qvkww.js → index-j95jp7ee.js}

@@ -11,7 +11,7 @@ import {
   spawnBunChild,
   spawnBunInheritedChild,
   ownerLossGuardEntry
-} from "./index-zrdcmg6j.js";
+} from "./index-72xtvcvr.js";
 import {
   errnoOf
 } from "./index-jj9228tt.js";
@@ -173,7 +173,7 @@ async function waitForProcessGroupExit(pid, deadline, killLiveMembers) {
 function createCommandDeadline(timeoutMs, reason) {
   assertPositiveSafeInteger("Command deadline", timeoutMs, RangeError);
   const controller = new AbortController;
-  const deadline = performance.now() + timeoutMs;
+  let deadline = performance.now() + timeoutMs;
   let timer;
   const schedule = () => {
     const remaining = deadline - performance.now();
@@ -188,6 +188,15 @@ function createCommandDeadline(timeoutMs, reason) {
     cancel() {
       if (timer !== undefined)
         clearTimeout(timer);
+    },
+    restart(nextMs) {
+      assertPositiveSafeInteger("Command deadline", nextMs, RangeError);
+      if (controller.signal.aborted)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      deadline = performance.now() + nextMs;
+      schedule();
     }
   };
 }
@@ -440,10 +449,16 @@ function nodeChild(input) {
     });
   const [executable, ...args] = ownerLossGuardCommand(input.ownerLoss, input.executable, input.args);
   const child = spawn(executable, args, {
-    cwd: input.cwd,
+    cwd: input.ownerLoss.cwdDescriptor === undefined ? input.cwd : undefined,
     env: input.env,
     detached: input.group,
-    stdio: ["pipe", "pipe", "pipe", "pipe"]
+    stdio: [
+      "pipe",
+      "pipe",
+      "pipe",
+      "pipe",
+      ...input.ownerLoss.cwdDescriptor === undefined ? [] : [input.ownerLoss.cwdDescriptor]
+    ]
   });
   const control = child.stdio[3];
   if (!(control instanceof Duplex)) {
@@ -451,7 +466,12 @@ function nodeChild(input) {
     throw new Error("Owner-loss guard supplied no control pipe");
   }
   attachOwnerLossControl(child, control);
-  return child;
+  const { stdin, stdout, stderr } = child;
+  if (!stdin || !stdout || !stderr) {
+    abortOwnerLossLaunch(child.pid);
+    throw new Error("Owner-loss guard supplied incomplete command pipes");
+  }
+  return Object.assign(child, { stdin, stdout, stderr });
 }
 var INHERITED_OUTPUT = {
   destroyed: true,
@@ -497,10 +517,16 @@ function spawnInheritedCommand(input) {
       });
     const [executable, ...args] = ownerLossGuardCommand(input.ownerLoss, input.executable, input.args);
     const spawned = spawn(executable, args, {
-      cwd: input.cwd,
+      cwd: input.ownerLoss.cwdDescriptor === undefined ? input.cwd : undefined,
       env: input.env,
       detached: input.group,
-      stdio: ["inherit", "inherit", "inherit", "pipe"]
+      stdio: [
+        "inherit",
+        "inherit",
+        "inherit",
+        "pipe",
+        ...input.ownerLoss.cwdDescriptor === undefined ? [] : [input.ownerLoss.cwdDescriptor]
+      ]
     });
     const control = spawned.stdio[3];
     if (!(control instanceof Duplex)) {
@@ -723,7 +749,13 @@ function launchNativeCommand({
     cwd: options.cwd,
     env: options.envPolicy === "ambient" ? { ...process.env, ...options.env } : options.env ?? {},
     group: options.group === "own" && (driver?.group ?? true),
-    ownerLoss: options.ownerLoss === "terminate" ? { entry: ownerLossGuardEntry(), signalTarget: options.stop.target } : undefined
+    ownerLoss: options.ownerLoss === "terminate" || driver?.cwdDescriptor !== undefined ? {
+      entry: ownerLossGuardEntry(),
+      signalTarget: options.stop.target,
+      ...driver?.cwdDescriptor !== undefined && {
+        cwdDescriptor: driver.cwdDescriptor
+      }
+    } : undefined
   };
   let inherited;
   if (!launch) {
@@ -914,6 +946,7 @@ async function terminateOwnedGroup(child, closed, cleanupTimeoutMs) {
 }
 
 // src/process/command-owner.ts
+var GUARD_START_FLOOR_MS = 5000;
 function startNativeCommand(input, onSpawn, driver) {
   const options = NativeCommandOptionsSchema.parse(input);
   options.signal?.throwIfAborted();
@@ -937,7 +970,8 @@ function startNativeCommand(input, onSpawn, driver) {
     options.signal?.removeEventListener("abort", abort);
     killOn?.removeEventListener("abort", kill);
   };
-  const deadline = timeoutMs === undefined ? undefined : createCommandDeadline(timeoutMs, new NativeCommandError2("COMMAND_LIMIT", "Command deadline exceeded", {
+  const guarded = options.ownerLoss === "terminate" || driver?.cwdDescriptor !== undefined;
+  const deadline = timeoutMs === undefined ? undefined : createCommandDeadline(guarded ? Math.max(timeoutMs, GUARD_START_FLOOR_MS) : timeoutMs, new NativeCommandError2("COMMAND_LIMIT", "Command deadline exceeded", {
     reason: "deadline"
   }));
   const expired = () => controller.abort(deadline?.signal.reason);
@@ -1038,6 +1072,8 @@ function startNativeCommand(input, onSpawn, driver) {
       ]);
       drains.catch((error) => controller.abort(error));
       const pid = await raceAbort(started, controller.signal);
+      if (timeoutMs !== undefined)
+        deadline?.restart(timeoutMs);
       if (pid !== undefined)
         options.onLeaderStarted?.({ pid });
       admitted.resolve();

package/dist/{index-2kbysk9s.js → index-m5m9rmvt.js}

@@ -23,6 +23,8 @@ function loadDarwinBinding() {
   }
   const methods = [
     "openDirectoryAt",
+    "reopenDirectory",
+    "changeDirectory",
     "openFileAt",
     "createFileAt",
     "createDirectoryAt",

package/dist/{index-r3db01kh.js → index-nwm3ww60.js}

@@ -1,6 +1,6 @@
 import {
   attemptExclusiveLock
-} from "./index-bz479f0x.js";
+} from "./index-gtx3eknx.js";
 import {
   sleep
 } from "./index-eemvahkc.js";