zeitlich 0.2.36 → 0.2.37

package/src/lib/subagent/tool.ts

@@ -6,9 +6,10 @@ export const SUBAGENT_TOOL_NAME = "Subagent" as const;
 function buildSubagentDescription(subagents: SubagentConfig[]): string {
   const subagentList = subagents
     .map((s) => {
-      const continuation = s.thread && s.thread !== "new"
-        ? "\n*(Supports thread continuation — pass a threadId to resume a previous conversation)*"
-        : "";
+      const continuation =
+        s.thread && s.thread !== "new"
+          ? "\n*(Supports thread continuation — pass a threadId to resume a previous conversation)*"
+          : "";
       return `## ${s.agentName}\n${s.description}${continuation}`;
     })
     .join("\n\n");

package/src/lib/subagent/types.ts

@@ -10,10 +10,24 @@ import type {
   SandboxInit,
   SubagentSandboxShutdown,
 } from "../lifecycle";
+import type { SandboxOps, SandboxSnapshot } from "../sandbox/types";
 
 /** ToolHandlerResponse with threadId required (subagents must always surface their thread) */
-export type SubagentHandlerResponse<TResult = null, TToolResponse = JsonValue> =
-  ToolHandlerResponse<TResult, TToolResponse> & { threadId: string; sandboxId?: string };
+export type SubagentHandlerResponse<
+  TResult = null,
+  TToolResponse = JsonValue,
+> = ToolHandlerResponse<TResult, TToolResponse> & {
+  threadId: string;
+  sandboxId?: string;
+  /** Snapshot captured on session exit when `sandboxShutdown === "snapshot"`. */
+  snapshot?: SandboxSnapshot;
+  /**
+   * Snapshot captured immediately after the sandbox was seeded (before the
+   * first agent turn) when `continuation === "snapshot"`. Only set on the
+   * first call that actually created the sandbox.
+   */
+  baseSnapshot?: SandboxSnapshot;
+};
 
 /**
  * Raw workflow input fields passed from parent to child workflow.
@@ -64,13 +78,19 @@ export type InferSubagentResult<T extends SubagentConfig> =
  * Sandbox configuration for a subagent.
  *
  * - `"none"` — no sandbox (default).
- * - `{ source: "inherit", continuation }` — reuse the parent's sandbox.
+ * - `{ source: "inherit", continuation, proxy }` — reuse the parent's sandbox.
  *   `continuation: "continue"` shares the parent sandbox directly;
  *   `continuation: "fork"` forks from the parent on every call.
- * - `{ source: "own", init?, continuation }` — the child gets its own sandbox.
- *   `init: "per-call"` (default) creates fresh each call (thread continuation
- *   uses the previous sandbox). `init: "once"` creates on the first call and
- *   stores it for all subsequent calls.
+ * - `{ source: "own", init?, continuation, proxy }` — the child gets its own
+ *   sandbox. `init: "per-call"` (default) creates fresh each call (thread
+ *   continuation uses the previous sandbox). `init: "once"` creates on the
+ *   first call and stores it for all subsequent calls.
+ *
+ * `proxy` is a factory that returns workflow-safe sandbox ops matching the
+ * subagent's own activities. Called once inside `createSubagentHandler` with
+ * `scope = agentName`, so the returned proxy resolves to the same activity
+ * prefix the child session uses. The parent uses it to destroy lingering
+ * sandboxes and delete stored snapshots at shutdown.
  */
 export type SubagentSandboxConfig =
   | "none"
@@ -78,12 +98,14 @@ export type SubagentSandboxConfig =
       source: "inherit";
       continuation: "continue" | "fork";
       shutdown?: SubagentSandboxShutdown;
+      proxy: (scope: string) => SandboxOps;
     }
   | {
       source: "own";
       init?: "per-call" | "once";
-      continuation: "continue" | "fork";
+      continuation: "continue" | "fork" | "snapshot";
       shutdown?: SubagentSandboxShutdown;
+      proxy: (scope: string) => SandboxOps;
     };
 
 /**
@@ -122,6 +144,21 @@ export interface SubagentConfig<TResult extends z.ZodType = z.ZodType> {
    * Sandbox strategy for this subagent.
    *
    * @see {@link SubagentSandboxConfig}
+   *
+   * @example
+   * ```ts
+   * import { proxyDaytonaSandboxOps } from "zeitlich/adapters/sandbox/daytona/workflow";
+   *
+   * const researcher: SubagentConfig = {
+   *   agentName: "researcher",
+   *   workflow: researcherWorkflow,
+   *   sandbox: {
+   *     source: "own",
+   *     continuation: "snapshot",
+   *     proxy: proxyDaytonaSandboxOps,
+   *   },
+   * };
+   * ```
    */
   sandbox?: SubagentSandboxConfig;
 }
@@ -157,12 +194,11 @@ export interface SubagentHooks<TArgs = unknown, TResult = unknown> {
 }
 
 /**
- * Extended response from the subagent `fn` — includes optional cleanup callbacks
- * stripped before signaling the parent.
+ * Response returned from a subagent workflow `fn`.
  *
  * When `TSandboxShutdown` is `"pause-until-parent-close"` or
- * `"keep-until-parent-close"`, both `destroySandbox` and `sandboxId` become
- * required so the parent can coordinate cleanup.
+ * `"keep-until-parent-close"`, the parent needs the `sandboxId` to destroy
+ * the sandbox at its own shutdown, so the field becomes required.
  */
 export type SubagentFnResult<
   TResult = null,
@@ -171,14 +207,8 @@ export type SubagentFnResult<
   (TSandboxShutdown extends
     | "pause-until-parent-close"
     | "keep-until-parent-close"
-    ? { destroySandbox: () => Promise<void>; sandboxId: string }
-    : { destroySandbox?: () => Promise<void> });
-
-/** Payload sent by a child workflow to signal its result back to the parent */
-export interface ChildResultSignalPayload {
-  childWorkflowId: string;
-  result: SubagentHandlerResponse;
-}
+    ? { sandboxId: string }
+    : { sandboxId?: string });
 
 /** Payload sent by a child workflow as soon as its sandbox is ready */
 export interface ChildSandboxReadySignalPayload {

package/src/lib/subagent/workflow.ts

@@ -2,8 +2,6 @@ import type { z } from "zod";
 import {
   workflowInfo,
   getExternalWorkflowHandle,
-  setHandler,
-  condition,
   ApplicationFailure,
 } from "@temporalio/workflow";
 import type {
@@ -14,11 +12,7 @@ import type {
   SubagentSessionInput,
 } from "./types";
 import type { SubagentSandboxShutdown } from "../lifecycle";
-import {
-  childResultSignal,
-  childSandboxReadySignal,
-  destroySandboxSignal,
-} from "./signals";
+import { childSandboxReadySignal } from "./signals";
 
 /**
  * Defines a subagent workflow with embedded metadata (name, description, resultSchema).
@@ -137,51 +131,17 @@ export function defineSubagentWorkflow(
       ...(workflowInput.thread && { thread: workflowInput.thread }),
       ...(workflowInput.sandbox && { sandbox: workflowInput.sandbox }),
       onSandboxReady: (sandboxId: string) => {
-        void parentHandle.signal(childSandboxReadySignal, {
-          childWorkflowId: workflowInfo().workflowId,
-          sandboxId,
-        });
+        const isReuse = workflowInput.sandbox?.mode === "continue";
+        if (!isReuse) {
+          void parentHandle.signal(childSandboxReadySignal, {
+            childWorkflowId: workflowInfo().workflowId,
+            sandboxId,
+          });
+        }
       },
     };
-    const { destroySandbox, ...result } = await fn(
-      prompt,
-      sessionInput,
-      context ?? {}
-    );
-
-    if (
-      effectiveShutdown === "pause-until-parent-close" ||
-      effectiveShutdown === "keep-until-parent-close"
-    ) {
-      if (!destroySandbox) {
-        throw ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a destroySandbox callback`,
-          nonRetryable: true,
-        });
-      }
-      if (!result.sandboxId) {
-        throw ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a sandboxId`,
-          nonRetryable: true,
-        });
-      }
-    }
-
-    await parentHandle.signal(childResultSignal, {
-      childWorkflowId: workflowInfo().workflowId,
-      result,
-    });
-
-    if (destroySandbox) {
-      let destroyRequested = false;
-      setHandler(destroySandboxSignal, () => {
-        destroyRequested = true;
-      });
-      await condition(() => destroyRequested);
-      await destroySandbox();
-    }
 
-    return result;
+    return fn(prompt, sessionInput, context ?? {});
   };
 
   // for temporal workflow name

package/src/lib/thread/id.test.ts

@@ -8,7 +8,7 @@ vi.mock("@temporalio/workflow", () => ({
     const bytes = Array.from({ length: 16 }, (_, i) =>
       ((uuidCounter * 31 + i * 7 + uuidCounter * i) & 0xff)
         .toString(16)
-        .padStart(2, "0"),
+        .padStart(2, "0")
     ).join("");
     return `${bytes.slice(0, 8)}-${bytes.slice(8, 12)}-${bytes.slice(12, 16)}-${bytes.slice(16, 20)}-${bytes.slice(20, 32)}`;
   },

package/src/lib/thread/id.ts

@@ -1,7 +1,6 @@
 import { uuid4 } from "@temporalio/workflow";
 
-const BASE62 =
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 
 /**
  * Generate a compact, workflow-deterministic identifier.

package/src/lib/thread/proxy.ts

@@ -25,7 +25,7 @@ import type { ThreadOps } from "../session/types";
 export function createThreadOpsProxy(
   adapterPrefix: string,
   scope?: string,
-  options?: Parameters<typeof proxyActivities>[0],
+  options?: Parameters<typeof proxyActivities>[0]
 ): ActivityInterfaceFor<ThreadOps> {
   const resolvedScope = scope ?? workflowInfo().workflowType;
 
@@ -39,11 +39,10 @@ export function createThreadOpsProxy(
         maximumInterval: "15m",
         backoffCoefficient: 4,
       },
-    },
+    }
   );
 
-  const prefix =
-    `${adapterPrefix}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
+  const prefix = `${adapterPrefix}${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
   const p = (key: string): string =>
     `${prefix}${key.charAt(0).toUpperCase()}${key.slice(1)}`;
 

package/src/lib/thread/types.ts

@@ -61,9 +61,17 @@ export interface BaseThreadManager<T> {
  */
 export interface ThreadManagerHooks<TStored, TPrepared = TStored> {
   /** Called for each stored message before SDK-specific processing (system extraction, role merging, format conversion) */
-  onPrepareMessage?: (message: TStored, index: number, thread: readonly TStored[]) => TStored;
+  onPrepareMessage?: (
+    message: TStored,
+    index: number,
+    thread: readonly TStored[]
+  ) => TStored;
   /** Called for each SDK-native message after all processing, right before the payload is returned */
-  onPreparedMessage?: (message: TPrepared, index: number, messages: readonly TPrepared[]) => TPrepared;
+  onPreparedMessage?: (
+    message: TPrepared,
+    index: number,
+    messages: readonly TPrepared[]
+  ) => TPrepared;
 }
 
 export interface ProviderThreadManager<
@@ -78,6 +86,6 @@ export interface ProviderThreadManager<
     id: string,
     toolCallId: string,
     toolName: string,
-    content: TToolContent,
+    content: TToolContent
   ): Promise<void>;
 }

package/src/lib/tool-router/index.ts

@@ -1,8 +1,4 @@
-export {
-  createToolRouter,
-  defineTool,
-  hasNoOtherToolCalls,
-} from "./router";
+export { createToolRouter, defineTool, hasNoOtherToolCalls } from "./router";
 export { withAutoAppend } from "./auto-append";
 export { withSandbox } from "./with-sandbox";
 export type { SandboxContext } from "./with-sandbox";

package/src/lib/tool-router/router-edge-cases.integration.test.ts

@@ -348,7 +348,7 @@ describe("createToolRouter edge cases", () => {
       parallel: true,
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+     
     const results = await router.processToolCalls([
       { id: "tc-1", name: "Unknown1", args: {} },
       { id: "tc-2", name: "Unknown2", args: {} },

package/src/lib/tool-router/router.ts

@@ -162,7 +162,8 @@ export function createToolRouter<T extends ToolMap>(
 
     return {
       content: JSON.stringify({
-        error: "The tool encountered an error. Please try again or use a different approach.",
+        error:
+          "The tool encountered an error. Please try again or use a different approach.",
       }),
       result: { error: errorStr, suppressed: true },
     };
@@ -201,7 +202,7 @@ export function createToolRouter<T extends ToolMap>(
   async function processToolCall(
     toolCall: ParsedToolCallUnion<T>,
     turn: number,
-    sandboxId?: string,
+    sandboxId?: string
   ): Promise<ToolCallResultUnion<TResults> | null> {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);

package/src/lib/tool-router/types.ts

@@ -124,7 +124,10 @@ export type AppendToolResultFn = ActivityFunctionWithOptions<
  * Tools that don't return additional data should use `data: null` (TResult defaults to null).
  * Tools that may fail to produce data should type TResult as `SomeType | null`.
  */
-export interface ToolHandlerResponse<TResult = null, TToolResponse = JsonValue> {
+export interface ToolHandlerResponse<
+  TResult = null,
+  TToolResponse = JsonValue,
+> {
   /** Content sent back to the LLM as the tool call response */
   toolResponse: TToolResponse;
   /** Data returned to the workflow and hooks for further processing */
@@ -172,7 +175,9 @@ export type ToolHandler<
 > = (
   args: TArgs,
   context: TContext
-) => ToolHandlerResponse<TResult, TToolResponse> | Promise<ToolHandlerResponse<TResult, TToolResponse>>;
+) =>
+  | ToolHandlerResponse<TResult, TToolResponse>
+  | Promise<ToolHandlerResponse<TResult, TToolResponse>>;
 
 /**
  * Activity-compatible tool handler that always returns a Promise.
@@ -195,7 +200,10 @@ export type ActivityToolHandler<
   TResult,
   TContext extends RouterContext = RouterContext,
   TToolResponse = JsonValue,
-> = (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult, TToolResponse>>;
+> = (
+  args: TArgs,
+  context: TContext
+) => Promise<ToolHandlerResponse<TResult, TToolResponse>>;
 
 /**
  * Extract the args type for a specific tool name from a tool map.

package/src/lib/tool-router/with-sandbox.ts

@@ -1,6 +1,10 @@
 import type { Sandbox } from "../sandbox/types";
 import type { JsonValue } from "../state/types";
-import type { ActivityToolHandler, RouterContext, ToolHandlerResponse } from "./types";
+import type {
+  ActivityToolHandler,
+  RouterContext,
+  ToolHandlerResponse,
+} from "./types";
 
 /**
  * Extended router context with a resolved {@link Sandbox} instance.
@@ -51,13 +55,23 @@ export interface SandboxContext extends RouterContext {
  * });
  * ```
  */
-export function withSandbox<TArgs, TResult, TSandbox extends Sandbox = Sandbox, TToolResponse = JsonValue>(
+export function withSandbox<
+  TArgs,
+  TResult,
+  TSandbox extends Sandbox = Sandbox,
+  TToolResponse = JsonValue,
+>(
   manager: { getSandbox(id: string): Promise<TSandbox> },
   handler: (
     args: TArgs,
-    context: RouterContext & { sandbox: TSandbox; sandboxId: string },
-  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>,
-): ActivityToolHandler<TArgs, TResult | null, RouterContext, TToolResponse | string> {
+    context: RouterContext & { sandbox: TSandbox; sandboxId: string }
+  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>
+): ActivityToolHandler<
+  TArgs,
+  TResult | null,
+  RouterContext,
+  TToolResponse | string
+> {
   return async (args, context) => {
     if (!context.sandboxId) {
       return {

package/src/lib/virtual-fs/filesystem.ts

@@ -67,7 +67,7 @@ export class VirtualFileSystem<
     private resolver: FileResolver<TCtx, TMeta>,
     private ctx: TCtx,
     workspaceBase = "/",
-    inlineFiles?: Record<string, string>,
+    inlineFiles?: Record<string, string>
   ) {
     this.workspaceBase = normalisePath(workspaceBase);
     this.entries = new Map(

package/src/lib/virtual-fs/index.ts

@@ -1,7 +1,11 @@
 export { VirtualFileSystem } from "./filesystem";
 export { withVirtualFs } from "./with-virtual-fs";
 export { createVirtualFsActivities } from "./manager";
-export { hasFileWithMimeType, filesWithMimeType, hasDirectory } from "./queries";
+export {
+  hasFileWithMimeType,
+  filesWithMimeType,
+  hasDirectory,
+} from "./queries";
 export { applyVirtualTreeMutations } from "./mutations";
 export { formatVirtualFileTree } from "./tree";
 export type { FileTreeAccessor } from "./queries";

package/src/lib/virtual-fs/mutations.ts

@@ -13,7 +13,7 @@ export function applyVirtualTreeMutations<TMeta = FileEntryMetadata>(
     get(key: "fileTree"): VirtualFileTree<TMeta>;
     set(key: "fileTree", value: VirtualFileTree<TMeta>): void;
   },
-  mutations: TreeMutation<TMeta>[],
+  mutations: TreeMutation<TMeta>[]
 ): VirtualFileTree<TMeta> {
   let tree = [...stateManager.get("fileTree")];
 
@@ -26,9 +26,7 @@ export function applyVirtualTreeMutations<TMeta = FileEntryMetadata>(
         tree = tree.filter((e) => e.path !== m.path);
         break;
       case "update":
-        tree = tree.map((e) =>
-          e.path === m.path ? { ...e, ...m.entry } : e
-        );
+        tree = tree.map((e) => (e.path === m.path ? { ...e, ...m.entry } : e));
         break;
     }
   }

package/src/lib/virtual-fs/queries.ts

@@ -25,10 +25,12 @@ export interface FileTreeAccessor<TMeta> {
  */
 export function hasFileWithMimeType<TMeta>(
   stateManager: FileTreeAccessor<TMeta>,
-  pattern: string | string[],
+  pattern: string | string[]
 ): boolean {
   const tree = stateManager.get("fileTree");
-  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
+  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(
+    buildMatcher
+  );
   return tree.some((entry) => {
     const meta = entry.metadata as Record<string, unknown> | undefined;
     const mime = meta?.mimeType;
@@ -41,7 +43,7 @@ export function hasFileWithMimeType<TMeta>(
  */
 export function filesWithMimeType<TMeta>(
   stateManager: FileTreeAccessor<TMeta>,
-  pattern: string,
+  pattern: string
 ): FileEntry<TMeta>[] {
   const tree = stateManager.get("fileTree");
   const match = buildMatcher(pattern);
@@ -66,7 +68,7 @@ export function filesWithMimeType<TMeta>(
  */
 export function hasDirectory<TMeta>(
   stateManager: FileTreeAccessor<TMeta>,
-  pattern: string,
+  pattern: string
 ): boolean {
   const tree = stateManager.get("fileTree");
   const match = buildGlobMatcher(pattern);
@@ -91,7 +93,9 @@ function buildMatcher(pattern: string): (value: string) => boolean {
 function buildGlobMatcher(pattern: string): (value: string) => boolean {
   if (!pattern.includes("*")) return (v) => v === pattern;
   const re = new RegExp(
-    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
+    "^" +
+      pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") +
+      "$"
   );
   return (v) => re.test(v);
 }

package/src/lib/virtual-fs/types.ts

@@ -104,7 +104,10 @@ export type PrefixedVirtualFsOps<
   [K in keyof VirtualFsOps<
     TCtx,
     TMeta
-  > as `virtualFs${Capitalize<TPrefix>}${Capitalize<K & string>}`]: VirtualFsOps<TCtx, TMeta>[K];
+  > as `virtualFs${Capitalize<TPrefix>}${Capitalize<K & string>}`]: VirtualFsOps<
+    TCtx,
+    TMeta
+  >[K];
 };
 
 // ============================================================================

package/src/lib/virtual-fs/virtual-fs.test.ts

@@ -53,7 +53,7 @@ function createMockResolver(): {
         id,
         typeof content === "string"
           ? content
-          : new TextDecoder().decode(content),
+          : new TextDecoder().decode(content)
       );
     },
 
@@ -63,7 +63,7 @@ function createMockResolver(): {
         id,
         typeof content === "string"
           ? content
-          : new TextDecoder().decode(content),
+          : new TextDecoder().decode(content)
       );
       const size =
         typeof content === "string"
@@ -286,9 +286,7 @@ describe("VirtualFileSystem", () => {
   });
 
   it("rm force does not throw for missing path", async () => {
-    await expect(
-      fs.rm("/nonexistent", { force: true }),
-    ).resolves.not.toThrow();
+    await expect(fs.rm("/nonexistent", { force: true })).resolves.not.toThrow();
   });
 
   // --- cp / mv ---
@@ -320,7 +318,7 @@ describe("VirtualFileSystem", () => {
 
   it("readlink throws SandboxNotSupportedError", async () => {
     await expect(fs.readlink("/src/index.ts")).rejects.toThrow(
-      SandboxNotSupportedError,
+      SandboxNotSupportedError
     );
   });
 });
@@ -349,7 +347,7 @@ describe("VirtualFileSystem — inlineFiles", () => {
       resolver,
       ctx,
       "/",
-      inlineFiles,
+      inlineFiles
     );
   }
 
@@ -418,7 +416,9 @@ describe("applyVirtualTreeMutations", () => {
     let fileTree = tree;
     return {
       get: (_key: "fileTree"): FileEntry[] => fileTree,
-      set: (_key: "fileTree", value: FileEntry[]): void => { fileTree = value; },
+      set: (_key: "fileTree", value: FileEntry[]): void => {
+        fileTree = value;
+      },
       current: (): FileEntry[] => fileTree,
     };
   }
@@ -490,9 +490,7 @@ describe("applyVirtualTreeMutations", () => {
   it("does not mutate the original array passed to the state manager", () => {
     const original = [...sampleTree];
     const sm = mockStateManager(sampleTree);
-    applyVirtualTreeMutations(sm, [
-      { type: "remove", path: "/src/index.ts" },
-    ]);
+    applyVirtualTreeMutations(sm, [{ type: "remove", path: "/src/index.ts" }]);
     expect(sampleTree).toEqual(original);
   });
 });

package/src/lib/workflow.test.ts

@@ -50,10 +50,13 @@ describe("defineWorkflow", () => {
       return { ok: true };
     });
 
-    await workflow({}, {
-      thread: { mode: "fork", threadId: "prev-1" },
-      sandbox: { mode: "continue", sandboxId: "sb-1" },
-    });
+    await workflow(
+      {},
+      {
+        thread: { mode: "fork", threadId: "prev-1" },
+        sandbox: { mode: "continue", sandboxId: "sb-1" },
+      }
+    );
 
     expect(capturedSession).toEqual({
       agentName: "test-workflow",

package/src/lib/workflow.ts

@@ -1,8 +1,4 @@
-import type {
-  ThreadInit,
-  SandboxInit,
-  SandboxShutdown,
-} from "./lifecycle";
+import type { ThreadInit, SandboxInit, SandboxShutdown } from "./lifecycle";
 
 /**
  * Session config fields derived from a main workflow input, ready to spread

package/src/tools/ask-user-question/tool.ts

@@ -42,6 +42,4 @@ Usage notes:
   strict: true,
 } satisfies ToolDefinition;
 
-export type AskUserQuestionArgs = z.infer<
-  typeof askUserQuestionTool.schema
->;
+export type AskUserQuestionArgs = z.infer<typeof askUserQuestionTool.schema>;

package/src/tools/glob/handler.ts

@@ -19,10 +19,7 @@ function matchGlob(pattern: string, path: string): boolean {
   return new RegExp(`^${regex}$`).test(path);
 }
 
-async function walk(
-  fs: Sandbox["fs"],
-  dir: string,
-): Promise<string[]> {
+async function walk(fs: Sandbox["fs"], dir: string): Promise<string[]> {
   const results: string[] = [];
   const entries = await fs.readdirWithFileTypes(dir);
   for (const entry of entries) {

package/src/tools/task-get/handler.ts

@@ -1,7 +1,4 @@
-import type {
-  AgentStateManager,
-  JsonSerializable,
-} from "../../lib/state";
+import type { AgentStateManager, JsonSerializable } from "../../lib/state";
 import type { ToolHandler } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
 import type { TaskGetArgs } from "./tool";
@@ -20,7 +17,9 @@ export function createTaskGetHandler<TCustom extends JsonSerializable<TCustom>>(
 
     if (!task) {
       return {
-        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        toolResponse: JSON.stringify({
+          error: `Task not found: ${args.taskId}`,
+        }),
         data: null,
       };
     }

package/src/tools/task-list/handler.ts

@@ -1,7 +1,4 @@
-import type {
-  AgentStateManager,
-  JsonSerializable,
-} from "../../lib/state";
+import type { AgentStateManager, JsonSerializable } from "../../lib/state";
 import type { ToolHandler } from "../../lib/tool-router";
 import type { WorkflowTask } from "../../lib/types";
 import type { TaskListArgs } from "./tool";