zeitlich 0.2.36 → 0.2.38

package/dist/workflow.cjs

@@ -113,7 +113,7 @@ function createToolRouter(options) {
       });
     }
   }
-  async function processToolCall(toolCall, turn, sandboxId) {
+  async function processToolCall(toolCall, turn, sandboxId, onRewindRequested) {
     const startTime = Date.now();
     const tool = toolMap.get(toolCall.name);
     const preResult = await runPreHooks(toolCall, tool, turn);
@@ -128,7 +128,7 @@ function createToolRouter(options) {
           reason: "Skipped by PreToolUse hook"
         })
       });
-      return null;
+      return { kind: "skipped" };
     }
     const effectiveArgs = preResult.args;
     workflow.log.debug("tool call dispatched", {
@@ -140,6 +140,7 @@ function createToolRouter(options) {
     let content;
     let resultAppended = false;
     let metadata;
+    let rewindRequested = false;
     try {
       if (tool) {
         const routerContext = {
@@ -157,11 +158,15 @@ function createToolRouter(options) {
         content = response.toolResponse;
         resultAppended = response.resultAppended === true;
         metadata = response.metadata;
+        rewindRequested = response.rewind === true;
       } else {
         result = { error: `Unknown tool: ${toolCall.name}` };
         content = JSON.stringify(result, null, 2);
       }
     } catch (error) {
+      if (workflow.isCancellation(error)) {
+        throw error;
+      }
       workflow.log.warn("tool call failed", {
         toolName: toolCall.name,
         toolCallId: toolCall.id,
@@ -179,6 +184,15 @@ function createToolRouter(options) {
       result = recovery.result;
       content = recovery.content;
     }
+    if (rewindRequested) {
+      const signal = {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name
+      };
+      workflow.log.info("tool requested rewind", { ...signal });
+      onRewindRequested?.(signal);
+      return { kind: "rewind", signal };
+    }
     if (!resultAppended) {
       const config = {
         threadId: options.threadId,
@@ -215,7 +229,7 @@ function createToolRouter(options) {
       turn,
       durationMs
     );
-    return toolResult;
+    return { kind: "result", value: toolResult };
   }
   return {
     hasTools() {
@@ -250,27 +264,59 @@ function createToolRouter(options) {
       }));
     },
     async processToolCalls(toolCalls, context) {
+      const attachRewind = (arr, rewind) => {
+        if (rewind) {
+          arr.rewind = rewind;
+        }
+        return arr;
+      };
       if (toolCalls.length === 0) {
-        return [];
+        return attachRewind([], void 0);
       }
       const turn = context?.turn ?? 0;
       const sandboxId = context?.sandboxId;
+      let rewindSignal;
       if (options.parallel) {
-        const results2 = await Promise.all(
-          toolCalls.map((tc) => processToolCall(tc, turn, sandboxId))
-        );
-        return results2.filter(
-          (r) => r !== null
+        const scope = new workflow.CancellationScope({ cancellable: true });
+        const onRewindRequested = (signal) => {
+          if (!rewindSignal) {
+            rewindSignal = signal;
+            scope.cancel();
+          }
+        };
+        const outcomes = await scope.run(
+          async () => Promise.allSettled(
+            toolCalls.map(
+              (tc) => processToolCall(tc, turn, sandboxId, onRewindRequested)
+            )
+          )
         );
+        const results2 = [];
+        for (const outcome of outcomes) {
+          if (outcome.status === "rejected") {
+            if (workflow.isCancellation(outcome.reason)) {
+              continue;
+            }
+            throw outcome.reason;
+          }
+          if (outcome.value.kind === "result") {
+            results2.push(outcome.value.value);
+          }
+        }
+        return attachRewind(results2, rewindSignal);
       }
       const results = [];
       for (const toolCall of toolCalls) {
-        const result = await processToolCall(toolCall, turn, sandboxId);
-        if (result !== null) {
-          results.push(result);
+        const outcome = await processToolCall(toolCall, turn, sandboxId);
+        if (outcome.kind === "rewind") {
+          rewindSignal = outcome.signal;
+          break;
+        }
+        if (outcome.kind === "result") {
+          results.push(outcome.value);
         }
       }
-      return results;
+      return attachRewind(results, rewindSignal);
     },
     async processToolCallsByName(toolCalls, toolName, handler, context) {
       const matchingCalls = toolCalls.filter((tc) => tc.name === toolName);
@@ -391,9 +437,7 @@ function createSubagentTool(subagents) {
     schema
   };
 }
-var childResultSignal = workflow.defineSignal("childResult");
 var childSandboxReadySignal = workflow.defineSignal("childSandboxReady");
-var destroySandboxSignal = workflow.defineSignal("destroySandbox");
 
 // src/lib/subagent/handler.ts
 function resolveSandboxConfig(config) {
@@ -417,25 +461,27 @@ function resolveSandboxConfig(config) {
 }
 function createSubagentHandler(subagents) {
   const { taskQueue: parentTaskQueue } = workflow.workflowInfo();
-  const childResults = /* @__PURE__ */ new Map();
+  const agentSandboxOps = /* @__PURE__ */ new Map();
+  for (const cfg of subagents) {
+    if (cfg.sandbox && cfg.sandbox !== "none") {
+      agentSandboxOps.set(cfg.agentName, cfg.sandbox.proxy(cfg.agentName));
+    }
+  }
   const pendingDestroys = /* @__PURE__ */ new Map();
   const threadSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxes = /* @__PURE__ */ new Map();
   const persistentSandboxCreating = /* @__PURE__ */ new Set();
   const lazyCreatorAgent = /* @__PURE__ */ new Map();
-  workflow.setHandler(childResultSignal, ({ childWorkflowId, result }) => {
-    childResults.set(childWorkflowId, result);
-  });
-  workflow.setHandler(
-    childSandboxReadySignal,
-    ({ childWorkflowId, sandboxId }) => {
-      const agentName = lazyCreatorAgent.get(childWorkflowId);
-      if (agentName && !persistentSandboxes.has(agentName)) {
-        persistentSandboxes.set(agentName, sandboxId);
-        lazyCreatorAgent.delete(childWorkflowId);
-      }
+  const threadSnapshots = /* @__PURE__ */ new Map();
+  const persistentBaseSnapshot = /* @__PURE__ */ new Map();
+  const persistentBaseSnapshotCreating = /* @__PURE__ */ new Set();
+  workflow.setHandler(childSandboxReadySignal, ({ childWorkflowId, sandboxId }) => {
+    const agentName = lazyCreatorAgent.get(childWorkflowId);
+    if (agentName && !persistentSandboxes.has(agentName)) {
+      persistentSandboxes.set(agentName, sandboxId);
+      lazyCreatorAgent.delete(childWorkflowId);
     }
-  );
+  });
   const handler = async (args, context) => {
     const config = subagents.find((s) => s.agentName === args.subagent);
     if (!config) {
@@ -446,6 +492,12 @@ function createSubagentHandler(subagents) {
     const childWorkflowId = `${args.subagent}-${getShortId()}`;
     const { sandboxId: parentSandboxId } = context;
     const sandboxCfg = resolveSandboxConfig(config.sandbox);
+    if (sandboxCfg.source !== "none" && !agentSandboxOps.has(config.agentName)) {
+      throw workflow.ApplicationFailure.create({
+        message: `Subagent "${config.agentName}" uses a sandbox but no \`sandbox.proxy\` is configured on its SubagentConfig`,
+        nonRetryable: true
+      });
+    }
     if (sandboxCfg.source === "inherit" && !parentSandboxId) {
       throw new Error(
         `Subagent "${config.agentName}" is configured with sandbox: "inherit" but the parent has no sandbox`
@@ -464,12 +516,39 @@ function createSubagentHandler(subagents) {
     let sandbox;
     let sandboxShutdownOverride;
     let isLazyCreator = false;
+    let isSnapshotBaseCreator = false;
     if (sandboxCfg.source === "inherit" && parentSandboxId) {
       if (sandboxCfg.continuation === "fork") {
         sandbox = { mode: "fork", sandboxId: parentSandboxId };
+      } else if (sandboxCfg.continuation === "snapshot") {
+        throw new Error(
+          `Subagent "${config.agentName}" has sandbox source "inherit" with continuation "snapshot" \u2014 snapshot continuation is only supported for source "own"`
+        );
       } else {
         sandbox = { mode: "inherit", sandboxId: parentSandboxId };
       }
+    } else if (sandboxCfg.source === "own" && sandboxCfg.continuation === "snapshot") {
+      const isLazy = sandboxCfg.init === "once";
+      let baseSnap;
+      if (continuationThreadId) {
+        baseSnap = threadSnapshots.get(continuationThreadId)?.snapshot;
+      }
+      if (!baseSnap && isLazy) {
+        baseSnap = persistentBaseSnapshot.get(config.agentName);
+        if (!baseSnap) {
+          if (persistentBaseSnapshotCreating.has(config.agentName)) {
+            await workflow.condition(() => persistentBaseSnapshot.has(config.agentName));
+            baseSnap = persistentBaseSnapshot.get(config.agentName);
+          } else {
+            persistentBaseSnapshotCreating.add(config.agentName);
+            isSnapshotBaseCreator = true;
+          }
+        }
+      }
+      if (baseSnap) {
+        sandbox = { mode: "from-snapshot", snapshot: baseSnap };
+      }
+      sandboxShutdownOverride = "snapshot";
     } else if (sandboxCfg.source === "own") {
       const isLazy = sandboxCfg.init === "once";
       let baseSandboxId;
@@ -520,31 +599,8 @@ function createSubagentHandler(subagents) {
       threadMode,
       sandboxSource: sandboxCfg.source
     });
-    const childHandle = await workflow.startChild(config.workflow, childOpts);
+    const childResult = await workflow.executeChild(config.workflow, childOpts);
     const effectiveShutdown = sandboxShutdownOverride ?? sandboxCfg.shutdown ?? "destroy";
-    if (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close") {
-      const key = isLazyCreator ? `persistent:${config.agentName}` : childWorkflowId;
-      pendingDestroys.set(key, childHandle);
-    }
-    await Promise.race([
-      workflow.condition(() => childResults.has(childWorkflowId)),
-      childHandle.result()
-    ]);
-    if (!childResults.has(childWorkflowId)) {
-      await workflow.condition(() => childResults.has(childWorkflowId));
-    }
-    const childResult = childResults.get(childWorkflowId);
-    childResults.delete(childWorkflowId);
-    if (!childResult) {
-      workflow.log.warn("subagent returned no result", {
-        subagent: config.agentName,
-        childWorkflowId
-      });
-      return {
-        toolResponse: "Subagent workflow did not signal a result",
-        data: null
-      };
-    }
     workflow.log.info("subagent completed", {
       subagent: config.agentName,
       childWorkflowId,
@@ -556,19 +612,42 @@ function createSubagentHandler(subagents) {
       usage,
       threadId: childThreadId,
       sandboxId: childSandboxId,
+      snapshot: childSnapshot,
+      baseSnapshot: childBaseSnapshot,
       metadata
     } = childResult;
     if (childSandboxId) {
-      if (sandboxCfg.source === "own" && sandboxCfg.init === "once" && !persistentSandboxes.has(config.agentName)) {
+      if (sandboxCfg.source === "own" && sandboxCfg.init === "once" && sandboxCfg.continuation !== "snapshot" && !persistentSandboxes.has(config.agentName)) {
         persistentSandboxes.set(config.agentName, childSandboxId);
-      } else if (allowsContinuation && childThreadId) {
+      } else if (allowsContinuation && childThreadId && sandboxCfg.source === "own" && sandboxCfg.continuation !== "snapshot") {
         threadSandboxes.set(childThreadId, childSandboxId);
       }
     }
+    if (childSandboxId && (effectiveShutdown === "pause-until-parent-close" || effectiveShutdown === "keep-until-parent-close")) {
+      const key = isLazyCreator ? `persistent:${config.agentName}` : childWorkflowId;
+      pendingDestroys.set(key, {
+        agentName: config.agentName,
+        sandboxId: childSandboxId
+      });
+    }
+    if (sandboxCfg.source === "own" && sandboxCfg.continuation === "snapshot") {
+      if (childSnapshot && childThreadId) {
+        threadSnapshots.set(childThreadId, {
+          agentName: config.agentName,
+          snapshot: childSnapshot
+        });
+      }
+      if (isSnapshotBaseCreator && childBaseSnapshot && !persistentBaseSnapshot.has(config.agentName)) {
+        persistentBaseSnapshot.set(config.agentName, childBaseSnapshot);
+      }
+    }
     if (isLazyCreator) {
       persistentSandboxCreating.delete(config.agentName);
       lazyCreatorAgent.delete(childWorkflowId);
     }
+    if (isSnapshotBaseCreator) {
+      persistentBaseSnapshotCreating.delete(config.agentName);
+    }
     if (!toolResponse) {
       return {
         toolResponse: "Subagent workflow returned no response",
@@ -604,22 +683,60 @@ function createSubagentHandler(subagents) {
     };
   };
   const destroySubagentSandboxes = async () => {
-    const handles = [...pendingDestroys.values()];
+    const entries = [...pendingDestroys.values()];
     pendingDestroys.clear();
     await Promise.all(
-      handles.map(async (handle) => {
+      entries.map(async ({ agentName, sandboxId }) => {
+        const ops = agentSandboxOps.get(agentName);
+        if (!ops) {
+          workflow.log.warn(
+            "Skipping sandbox destroy \u2014 no sandbox.proxy registered for agent",
+            { agentName, sandboxId }
+          );
+          return;
+        }
+        try {
+          await ops.destroySandbox(sandboxId);
+        } catch (err) {
+          workflow.log.warn("Failed to destroy subagent sandbox", {
+            agentName,
+            sandboxId,
+            error: err
+          });
+        }
+      })
+    );
+  };
+  const cleanupSubagentSnapshots = async () => {
+    const tagged = [];
+    for (const entry of threadSnapshots.values()) tagged.push(entry);
+    for (const [agentName, snapshot] of persistentBaseSnapshot.entries()) {
+      tagged.push({ agentName, snapshot });
+    }
+    threadSnapshots.clear();
+    persistentBaseSnapshot.clear();
+    await Promise.all(
+      tagged.map(async ({ agentName, snapshot }) => {
+        const ops = agentSandboxOps.get(agentName);
+        if (!ops) {
+          workflow.log.warn(
+            "Skipping snapshot delete \u2014 no sandbox.proxy registered for agent",
+            { agentName }
+          );
+          return;
+        }
         try {
-          await handle.signal(destroySandboxSignal);
-          await handle.result();
+          await ops.deleteSandboxSnapshot(snapshot);
         } catch (err) {
-          workflow.log.warn("Failed to signal destroySandbox to child workflow", {
+          workflow.log.warn("Failed to delete subagent snapshot", {
+            agentName,
             error: err
           });
         }
       })
     );
   };
-  return { handler, destroySubagentSandboxes };
+  return { handler, destroySubagentSandboxes, cleanupSubagentSnapshots };
 }
 
 // src/lib/subagent/register.ts
@@ -633,7 +750,7 @@ function buildSubagentRegistration(subagents) {
     if (s.hooks) subagentHooksMap.set(s.agentName, s.hooks);
   }
   const resolveSubagentName = (args) => args.subagent;
-  const { handler, destroySubagentSandboxes } = createSubagentHandler(subagents);
+  const { handler, destroySubagentSandboxes, cleanupSubagentSnapshots } = createSubagentHandler(subagents);
   const registration = {
     name: SUBAGENT_TOOL_NAME,
     enabled: () => getEnabled().length > 0,
@@ -657,7 +774,7 @@ function buildSubagentRegistration(subagents) {
       }
     }
   };
-  return { registration, destroySubagentSandboxes };
+  return { registration, destroySubagentSandboxes, cleanupSubagentSnapshots };
 }
 var READ_SKILL_TOOL_NAME = "ReadSkill";
 function buildReadSkillDescription(skills) {
@@ -730,9 +847,7 @@ function validateSkillNames(skills) {
   const names = skills.map((s) => s.name);
   const dupes = names.filter((n, i) => names.indexOf(n) !== i);
   if (dupes.length > 0) {
-    throw new Error(
-      `Duplicate skill names: ${[...new Set(dupes)].join(", ")}`
-    );
+    throw new Error(`Duplicate skill names: ${[...new Set(dupes)].join(", ")}`);
   }
 }
 function buildSkillRegistration(skills) {
@@ -798,15 +913,18 @@ async function createSession({
     initializeThread,
     appendSystemMessage,
     appendAgentMessage,
-    forkThread
+    forkThread,
+    truncateThread
   } = threadOps;
   const plugins = [];
   let destroySubagentSandboxes;
+  let cleanupSubagentSnapshots;
   if (subagents) {
     const result = buildSubagentRegistration(subagents);
     if (result) {
       plugins.push(result.registration);
       destroySubagentSandboxes = result.destroySubagentSandboxes;
+      cleanupSubagentSnapshots = result.cleanupSubagentSnapshots;
     }
   }
   if (skills) {
@@ -859,6 +977,9 @@ async function createSession({
       const sandboxMode = sandboxInit?.mode;
       let sandboxId;
       let sandboxOwned = false;
+      let baseSnapshot;
+      let exitSnapshot;
+      let freshlyCreated = false;
       if (sandboxMode === "inherit") {
         const inheritInit = sandboxInit;
         sandboxId = inheritInit.sandboxId;
@@ -887,8 +1008,23 @@ async function createSession({
             nonRetryable: true
           });
         }
+        const forkInit = sandboxInit;
         sandboxId = await sandboxOps.forkSandbox(
-          sandboxInit.sandboxId
+          forkInit.sandboxId,
+          forkInit.options
+        );
+        sandboxOwned = true;
+      } else if (sandboxMode === "from-snapshot") {
+        if (!sandboxOps) {
+          throw workflow.ApplicationFailure.create({
+            message: "No sandboxOps provided \u2014 cannot restore sandbox",
+            nonRetryable: true
+          });
+        }
+        const restoreInit = sandboxInit;
+        sandboxId = await sandboxOps.restoreSandbox(
+          restoreInit.snapshot,
+          restoreInit.options
         );
         sandboxOwned = true;
       } else if (sandboxOps) {
@@ -899,9 +1035,13 @@ async function createSession({
         if (result) {
           sandboxId = result.sandboxId;
           sandboxOwned = true;
+          freshlyCreated = true;
         }
       }
-      if (sandboxId && onSandboxReady) {
+      if (sandboxId && sandboxOwned && freshlyCreated && sandboxShutdown === "snapshot" && sandboxOps) {
+        baseSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+      }
+      if (sandboxId && sandboxOwned && onSandboxReady) {
         onSandboxReady(sandboxId);
       }
       if (virtualFsConfig) {
@@ -967,18 +1107,25 @@ async function createSession({
         threadKey
       );
       let exitReason = "completed";
+      let finalMessage = null;
       try {
         while (stateManager.isRunning() && !stateManager.isTerminal() && stateManager.getTurns() < maxTurns) {
           stateManager.incrementTurns();
           const currentTurn = stateManager.getTurns();
           workflow.log.debug("turn started", { agentName, threadId, turn: currentTurn });
           stateManager.setTools(toolRouter.getToolDefinitions());
-          const { message, rawToolCalls, usage } = await runAgent({
+          const {
+            message,
+            rawToolCalls,
+            usage,
+            threadLengthAtCall
+          } = await runAgent({
             threadId,
             threadKey,
             agentName,
             metadata
           });
+          const preAssistantLength = threadLengthAtCall;
           await appendAgentMessage(threadId, workflow.uuid4(), message, threadKey);
           if (usage) {
             stateManager.updateUsage(usage);
@@ -993,21 +1140,8 @@ async function createSession({
           if (!toolRouter.hasTools() || rawToolCalls.length === 0) {
             stateManager.complete();
             exitReason = "completed";
-            workflow.log.info("session ended", {
-              agentName,
-              threadId,
-              exitReason,
-              turns: currentTurn,
-              durationMs: Date.now() - sessionStartMs,
-              usage: stateManager.getTotalUsage()
-            });
-            return {
-              threadId,
-              finalMessage: message,
-              exitReason,
-              usage: stateManager.getTotalUsage(),
-              sandboxId
-            };
+            finalMessage = message;
+            break;
           }
           const parsedToolCalls = [];
           for (const tc of rawToolCalls) {
@@ -1037,6 +1171,24 @@ async function createSession({
               stateManager.updateUsage(result.usage);
             }
           }
+          const rewind = toolCallResults.rewind;
+          if (rewind) {
+            workflow.log.info("rewinding turn", {
+              agentName,
+              threadId,
+              turn: currentTurn,
+              toolCallId: rewind.toolCallId,
+              toolName: rewind.toolName
+            });
+            if (preAssistantLength === void 0) {
+              throw workflow.ApplicationFailure.create({
+                message: "Rewind requested but runAgent did not report `threadLengthAtCall`; the adapter must populate it to support rewinds.",
+                nonRetryable: true
+              });
+            }
+            await truncateThread(threadId, preAssistantLength, threadKey);
+            continue;
+          }
           if (stateManager.getStatus() === "WAITING_FOR_INPUT") {
             const conditionMet = await workflow.condition(
               () => stateManager.getStatus() === "RUNNING",
@@ -1079,11 +1231,21 @@ async function createSession({
             case "pause-until-parent-close":
               await sandboxOps.pauseSandbox(sandboxId);
               break;
+            case "keep":
+            case "keep-until-parent-close":
+              break;
+            case "snapshot":
+              exitSnapshot = await sandboxOps.snapshotSandbox(sandboxId);
+              await sandboxOps.destroySandbox(sandboxId);
+              break;
           }
         }
         if (destroySubagentSandboxes) {
           await destroySubagentSandboxes();
         }
+        if (cleanupSubagentSnapshots) {
+          await cleanupSubagentSnapshots();
+        }
       }
       workflow.log.info("session ended", {
         agentName,
@@ -1091,14 +1253,18 @@ async function createSession({
         exitReason,
         turns: stateManager.getTurns(),
         durationMs: Date.now() - sessionStartMs,
-        usage: stateManager.getTotalUsage()
+        usage: stateManager.getTotalUsage(),
+        ...baseSnapshot && { hasBaseSnapshot: true },
+        ...exitSnapshot && { hasExitSnapshot: true }
       });
       return {
         threadId,
-        finalMessage: null,
+        finalMessage,
         exitReason,
         usage: stateManager.getTotalUsage(),
-        sandboxId
+        sandboxId,
+        ...baseSnapshot && { baseSnapshot },
+        ...exitSnapshot && { snapshot: exitSnapshot }
       };
     }
   };
@@ -1309,44 +1475,16 @@ function defineSubagentWorkflow(config, fn) {
       ...workflowInput.thread && { thread: workflowInput.thread },
       ...workflowInput.sandbox && { sandbox: workflowInput.sandbox },
       onSandboxReady: (sandboxId) => {
-        void parentHandle.signal(childSandboxReadySignal, {
-          childWorkflowId: workflow.workflowInfo().workflowId,
-          sandboxId
-        });
+        const isReuse = workflowInput.sandbox?.mode === "continue";
+        if (!isReuse) {
+          void parentHandle.signal(childSandboxReadySignal, {
+            childWorkflowId: workflow.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 workflow.ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a destroySandbox callback`,
-          nonRetryable: true
-        });
-      }
-      if (!result.sandboxId) {
-        throw workflow.ApplicationFailure.create({
-          message: `Subagent "${config.name}" has sandboxShutdown="${effectiveShutdown}" but fn did not return a sandboxId`,
-          nonRetryable: true
-        });
-      }
-    }
-    await parentHandle.signal(childResultSignal, {
-      childWorkflowId: workflow.workflowInfo().workflowId,
-      result
-    });
-    if (destroySandbox) {
-      let destroyRequested = false;
-      workflow.setHandler(destroySandboxSignal, () => {
-        destroyRequested = true;
-      });
-      await workflow.condition(() => destroyRequested);
-      await destroySandbox();
-    }
-    return result;
+    return fn(prompt, sessionInput, context ?? {});
   };
   Object.defineProperty(workflow$1, "name", { value: config.name });
   return Object.assign(workflow$1, {
@@ -1456,9 +1594,7 @@ function applyVirtualTreeMutations(stateManager, mutations) {
         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;
     }
   }
@@ -1517,7 +1653,9 @@ function formatVirtualFileTree(entries, opts = {}) {
 // src/lib/virtual-fs/queries.ts
 function hasFileWithMimeType(stateManager, pattern) {
   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;
     const mime = meta?.mimeType;
@@ -1578,7 +1716,9 @@ function proxyVirtualFsOps(scope, options) {
 // src/lib/skills/parse.ts
 function parseSkillFile(raw) {
   const trimmed = raw.replace(/^\uFEFF/, "");
-  const match = trimmed.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/);
+  const match = trimmed.match(
+    /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/
+  );
   if (!match) {
     throw new Error(
       "SKILL.md must start with YAML frontmatter delimited by ---"
@@ -1850,7 +1990,9 @@ function createTaskGetHandler(stateManager) {
     const task = stateManager.getTask(args.taskId) ?? null;
     if (!task) {
       return {
-        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        toolResponse: JSON.stringify({
+          error: `Task not found: ${args.taskId}`
+        }),
         data: null
       };
     }
@@ -1893,7 +2035,9 @@ function createTaskUpdateHandler(stateManager) {
     const task = stateManager.getTask(args.taskId);
     if (!task) {
       return {
-        toolResponse: JSON.stringify({ error: `Task not found: ${args.taskId}` }),
+        toolResponse: JSON.stringify({
+          error: `Task not found: ${args.taskId}`
+        }),
         data: null
       };
     }