@posthog/agent 2.1.131 → 2.1.137

package/dist/server/agent-server.js

@@ -513,7 +513,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os4 = __require("os");
+    var os5 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -561,7 +561,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os4.release().split(".");
+        const osRelease = os5.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -809,10 +809,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log = debug_1.default("@kwsites/file-exists");
-    function check(path8, isFile, isDirectory) {
-      log(`checking %s`, path8);
+    function check(path9, isFile, isDirectory) {
+      log(`checking %s`, path9);
       try {
-        const stat = fs_1.statSync(path8);
+        const stat = fs_1.statSync(path9);
         if (stat.isFile() && isFile) {
           log(`[OK] path represents a file`);
           return true;
@@ -832,8 +832,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path8, type = exports.READABLE) {
-      return check(path8, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path9, type = exports.READABLE) {
+      return check(path9, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -908,7 +908,7 @@ import { Hono } from "hono";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.131",
+  version: "2.1.137",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -984,7 +984,6 @@ var package_default = {
     "@twig/git": "workspace:*",
     "@types/bun": "latest",
     "@types/tar": "^6.1.13",
-    minimatch: "^10.0.3",
     msw: "^2.12.7",
     tsup: "^8.5.1",
     tsx: "^4.20.6",
@@ -1005,6 +1004,7 @@ var package_default = {
     commander: "^14.0.2",
     hono: "^4.11.7",
     jsonwebtoken: "^9.0.2",
+    minimatch: "^10.0.3",
     tar: "^7.5.0",
     uuid: "13.0.0",
     "yoga-wasm-web": "^0.3.3",
@@ -1285,13 +1285,16 @@ function nodeWritableToWebWritable(nodeStream) {
 }
 
 // src/adapters/claude/claude-agent.ts
-import * as fs2 from "fs";
-import * as os3 from "os";
-import * as path3 from "path";
+import { randomUUID } from "crypto";
+import * as fs3 from "fs";
+import * as os4 from "os";
+import * as path4 from "path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
 import {
+  getSessionMessages,
+  listSessions,
   query
 } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
@@ -1313,7 +1316,7 @@ function unreachable(value, logger) {
   try {
     valueAsString = JSON.stringify(value);
   } catch {
-    valueAsString = value;
+    valueAsString = String(value);
   }
   logger.error(`Unexpected case: ${valueAsString}`);
 }
@@ -1385,19 +1388,20 @@ var BaseAcpAgent = class {
   }
   async cancel(params) {
     if (this.sessionId !== params.sessionId) {
-      throw new Error("Session not found");
+      throw new Error("Session ID mismatch");
     }
     this.session.cancelled = true;
     const meta = params._meta;
     if (meta?.interruptReason) {
       this.session.interruptReason = meta.interruptReason;
     }
-    await this.interruptSession();
+    await this.interrupt();
   }
   async closeSession() {
     try {
       this.session.abortController.abort();
       await this.cancel({ sessionId: this.sessionId });
+      this.session.settingsManager.dispose();
       this.logger.info("Closed session", { sessionId: this.sessionId });
     } catch (err) {
       this.logger.warn("Failed to close session", {
@@ -1572,8 +1576,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path8, oldText, newText) {
-    this.items.push({ type: "diff", path: path8, oldText, newText });
+  diff(path9, oldText, newText) {
+    this.items.push({ type: "diff", path: path9, oldText, newText });
     return this;
   }
   build() {
@@ -1593,7 +1597,7 @@ var registerHookCallback = (toolUseID, {
     onPostToolUseHook
   };
 };
-var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
+var createPostToolUseHook = ({ onModeChange, logger }) => async (input, toolUseID) => {
   if (input.hook_event_name === "PostToolUse") {
     const toolName = input.tool_name;
     if (onModeChange && toolName === "EnterPlanMode") {
@@ -1608,11 +1612,54 @@ var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
           input.tool_response
         );
         delete toolUseCallbacks[toolUseID];
+      } else {
+        logger?.error(
+          `No onPostToolUseHook found for tool use ID: ${toolUseID}`
+        );
+        delete toolUseCallbacks[toolUseID];
       }
     }
   }
   return { continue: true };
 };
+var createPreToolUseHook = (settingsManager, logger) => async (input, _toolUseID) => {
+  if (input.hook_event_name !== "PreToolUse") {
+    return { continue: true };
+  }
+  const toolName = input.tool_name;
+  const toolInput = input.tool_input;
+  const permissionCheck = settingsManager.checkPermission(
+    toolName,
+    toolInput
+  );
+  if (permissionCheck.decision !== "ask") {
+    logger.info(
+      `[PreToolUseHook] Tool: ${toolName}, Decision: ${permissionCheck.decision}, Rule: ${permissionCheck.rule}`
+    );
+  }
+  switch (permissionCheck.decision) {
+    case "allow":
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          permissionDecisionReason: `Allowed by settings rule: ${permissionCheck.rule}`
+        }
+      };
+    case "deny":
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: `Denied by settings rule: ${permissionCheck.rule}`
+        }
+      };
+    default:
+      return { continue: true };
+  }
+};
 
 // src/adapters/claude/mcp/tool-metadata.ts
 var mcpToolMetadataCache = /* @__PURE__ */ new Map();
@@ -1689,79 +1736,7 @@ var SYSTEM_REMINDER = `
 <system-reminder>
 Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.
 </system-reminder>`;
-function replaceAndCalculateLocation(fileContent, edits) {
-  let currentContent = fileContent;
-  const randomHex = Array.from(crypto.getRandomValues(new Uint8Array(5))).map((b) => b.toString(16).padStart(2, "0")).join("");
-  const markerPrefix = `__REPLACE_MARKER_${randomHex}_`;
-  let markerCounter = 0;
-  const markers = [];
-  for (const edit of edits) {
-    if (edit.oldText === "") {
-      throw new Error(
-        `The provided \`old_string\` is empty.
-
-No edits were applied.`
-      );
-    }
-    if (edit.replaceAll) {
-      const parts = [];
-      let lastIndex = 0;
-      let searchIndex = 0;
-      while (true) {
-        const index = currentContent.indexOf(edit.oldText, searchIndex);
-        if (index === -1) {
-          if (searchIndex === 0) {
-            throw new Error(
-              `The provided \`old_string\` does not appear in the file: "${edit.oldText}".
-
-No edits were applied.`
-            );
-          }
-          break;
-        }
-        parts.push(currentContent.substring(lastIndex, index));
-        const marker = `${markerPrefix}${markerCounter++}__`;
-        markers.push(marker);
-        parts.push(marker + edit.newText);
-        lastIndex = index + edit.oldText.length;
-        searchIndex = lastIndex;
-      }
-      parts.push(currentContent.substring(lastIndex));
-      currentContent = parts.join("");
-    } else {
-      const index = currentContent.indexOf(edit.oldText);
-      if (index === -1) {
-        throw new Error(
-          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".
-
-No edits were applied.`
-        );
-      } else {
-        const marker = `${markerPrefix}${markerCounter++}__`;
-        markers.push(marker);
-        currentContent = currentContent.substring(0, index) + marker + edit.newText + currentContent.substring(index + edit.oldText.length);
-      }
-    }
-  }
-  const lineNumbers = [];
-  for (const marker of markers) {
-    const index = currentContent.indexOf(marker);
-    if (index !== -1) {
-      const lineNumber = Math.max(
-        0,
-        currentContent.substring(0, index).split(/\r\n|\r|\n/).length - 1
-      );
-      lineNumbers.push(lineNumber);
-    }
-  }
-  let finalContent = currentContent;
-  for (const marker of markers) {
-    finalContent = finalContent.replace(marker, "");
-  }
-  const uniqueLineNumbers = [...new Set(lineNumbers)].sort();
-  return { newContent: finalContent, lineNumbers: uniqueLineNumbers };
-}
-function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ debug: false, prefix: "[ClaudeTools]" })) {
+function toolInfoFromToolUse(toolUse, options) {
   const name = toolUse.name;
   const input = toolUse.input;
   switch (name) {
@@ -1786,6 +1761,13 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
         locations: input?.notebook_path ? [{ path: String(input.notebook_path) }] : []
       };
     case "Bash":
+      if (options?.supportsTerminalOutput && options?.toolUseId) {
+        return {
+          title: input?.description ? String(input.description) : "Execute command",
+          kind: "execute",
+          content: [{ type: "terminal", terminalId: options.toolUseId }]
+        };
+      }
       return {
         title: input?.description ? String(input.description) : "Execute command",
         kind: "execute",
@@ -1806,11 +1788,11 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
     case "Read": {
       let limit = "";
       const inputLimit = input?.limit;
-      const inputOffset = input?.offset ?? 0;
+      const inputOffset = input?.offset ?? 1;
       if (inputLimit) {
-        limit = ` (${inputOffset + 1} - ${inputOffset + inputLimit})`;
-      } else if (inputOffset) {
-        limit = ` (from line ${inputOffset + 1})`;
+        limit = ` (${inputOffset} - ${inputOffset + inputLimit - 1})`;
+      } else if (inputOffset > 1) {
+        limit = ` (from line ${inputOffset})`;
       }
       return {
         title: `Read ${input?.file_path ? String(input.file_path) : "File"}${limit}`,
@@ -1832,39 +1814,21 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
         locations: []
       };
     case "Edit": {
-      const path8 = input?.file_path ? String(input.file_path) : void 0;
-      let oldText = input?.old_string ? String(input.old_string) : null;
-      let newText = input?.new_string ? String(input.new_string) : "";
-      let affectedLines = [];
-      if (path8 && oldText) {
-        try {
-          const oldContent = cachedFileContent[path8] || "";
-          const newContent = replaceAndCalculateLocation(oldContent, [
-            {
-              oldText,
-              newText,
-              replaceAll: false
-            }
-          ]);
-          oldText = oldContent;
-          newText = newContent.newContent;
-          affectedLines = newContent.lineNumbers;
-        } catch (e) {
-          logger.error("Failed to edit file", e);
-        }
-      }
+      const path9 = input?.file_path ? String(input.file_path) : void 0;
+      const oldText = input?.old_string ? String(input.old_string) : null;
+      const newText = input?.new_string ? String(input.new_string) : "";
       return {
-        title: path8 ? `Edit \`${path8}\`` : "Edit",
+        title: path9 ? `Edit \`${path9}\`` : "Edit",
         kind: "edit",
-        content: input && path8 ? [
+        content: input && path9 ? [
           {
             type: "diff",
-            path: path8,
+            path: path9,
             oldText,
             newText
           }
         ] : [],
-        locations: path8 ? affectedLines.length > 0 ? affectedLines.map((line) => ({ line, path: path8 })) : [{ path: path8 }] : []
+        locations: path9 ? [{ path: path9 }] : []
       };
     }
     case "Write": {
@@ -1918,10 +1882,10 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
       }
       if (input?.output_mode) {
         switch (input.output_mode) {
-          case "FilesWithMatches":
+          case "files_with_matches":
             label += " -l";
             break;
-          case "Count":
+          case "count":
             label += " -c";
             break;
           default:
@@ -1940,7 +1904,9 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
       if (input?.multiline) {
         label += " -P";
       }
-      label += ` "${input?.pattern ? String(input.pattern) : ""}"`;
+      if (input?.pattern) {
+        label += ` "${String(input.pattern)}"`;
+      }
       if (input?.path) {
         label += ` ${String(input.path)}`;
       }
@@ -2034,7 +2000,49 @@ function mcpToolInfo(name, _input) {
     content: []
   };
 }
-function toolUpdateFromToolResult(toolResult, toolUse) {
+function toolUpdateFromEditToolResponse(toolResponse) {
+  if (!toolResponse || typeof toolResponse !== "object") return null;
+  const response = toolResponse;
+  const patches = response.structuredPatch;
+  if (!Array.isArray(patches) || patches.length === 0) return null;
+  const content = [];
+  const locations = [];
+  for (const patch of patches) {
+    if (!patch.hunks || patch.hunks.length === 0) continue;
+    const filePath = patch.newFileName || patch.oldFileName;
+    const oldLines = [];
+    const newLines = [];
+    for (const hunk of patch.hunks) {
+      for (const line of hunk.lines) {
+        if (line.startsWith("-")) {
+          oldLines.push(line.slice(1));
+        } else if (line.startsWith("+")) {
+          newLines.push(line.slice(1));
+        } else if (line.startsWith(" ")) {
+          oldLines.push(line.slice(1));
+          newLines.push(line.slice(1));
+        }
+      }
+    }
+    content.push({
+      type: "diff",
+      path: filePath,
+      oldText: oldLines.join("\n"),
+      newText: newLines.join("\n")
+    });
+    const firstHunk = patch.hunks[0];
+    locations.push({
+      path: filePath,
+      line: firstHunk.newStart
+    });
+  }
+  if (content.length === 0) return null;
+  return { content, locations };
+}
+function toolUpdateFromToolResult(toolResult, toolUse, options) {
+  if ("is_error" in toolResult && toolResult.is_error && toolResult.content && toolResult.content.length > 0) {
+    return toAcpContentUpdate(toolResult.content, true);
+  }
   switch (toolUse?.name) {
     case "Read":
       if (Array.isArray(toolResult.content) && toolResult.content.length > 0) {
@@ -2051,6 +2059,16 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
                 )
               };
             }
+            if (itemObj.type === "image" && itemObj.source) {
+              return {
+                type: "content",
+                content: {
+                  type: "image",
+                  data: itemObj.source.data ?? "",
+                  mimeType: itemObj.source.media_type ?? "image/png"
+                }
+              };
+            }
             return {
               type: "content",
               content: item
@@ -2066,18 +2084,51 @@ function toolUpdateFromToolResult(toolResult, toolUse) {
       }
       return {};
     case "Bash": {
-      return toAcpContentUpdate(
-        toolResult.content,
-        "is_error" in toolResult ? toolResult.is_error : false
-      );
-    }
-    case "Edit":
-    case "Write": {
-      if ("is_error" in toolResult && toolResult.is_error && toolResult.content && toolResult.content.length > 0) {
-        return toAcpContentUpdate(toolResult.content, true);
+      const result = toolResult.content;
+      const terminalId = "tool_use_id" in toolResult ? String(toolResult.tool_use_id) : "";
+      const isError = "is_error" in toolResult && toolResult.is_error;
+      let output = "";
+      let exitCode = isError ? 1 : 0;
+      if (result && typeof result === "object" && "type" in result && result.type === "bash_code_execution_result") {
+        const bashResult = result;
+        output = [bashResult.stdout, bashResult.stderr].filter(Boolean).join("\n");
+        exitCode = bashResult.return_code;
+      } else if (typeof result === "string") {
+        output = result;
+      } else if (Array.isArray(result) && result.length > 0 && "text" in result[0] && typeof result[0].text === "string") {
+        output = result.map((c) => c.text ?? "").join("\n");
+      }
+      if (options?.supportsTerminalOutput) {
+        return {
+          content: [{ type: "terminal", terminalId }],
+          _meta: {
+            terminal_info: {
+              terminal_id: terminalId
+            },
+            terminal_output: {
+              terminal_id: terminalId,
+              data: output
+            },
+            terminal_exit: {
+              terminal_id: terminalId,
+              exit_code: exitCode,
+              signal: null
+            }
+          }
+        };
+      }
+      if (output.trim()) {
+        return {
+          content: toolContent().text(`\`\`\`console
+${output.trimEnd()}
+\`\`\``).build()
+        };
       }
       return {};
     }
+    case "Edit":
+    case "Write":
+      return {};
     case "ExitPlanMode": {
       return { title: "Exited Plan Mode" };
     }
@@ -2237,6 +2288,7 @@ function handleThinkingChunk(chunk, parentToolCallId) {
   return update;
 }
 function handleToolUseChunk(chunk, ctx) {
+  const alreadyCached = chunk.id in ctx.toolUseCache;
   ctx.toolUseCache[chunk.id] = chunk;
   if (chunk.name === "TodoWrite") {
     const input = chunk.input;
@@ -2248,37 +2300,60 @@ function handleToolUseChunk(chunk, ctx) {
     }
     return null;
   }
-  registerHookCallback(chunk.id, {
-    onPostToolUseHook: async (toolUseId, _toolInput, toolResponse) => {
-      const toolUse = ctx.toolUseCache[toolUseId];
-      if (toolUse) {
-        await ctx.client.sessionUpdate({
-          sessionId: ctx.sessionId,
-          update: {
-            _meta: toolMeta(toolUse.name, toolResponse, ctx.parentToolCallId),
-            toolCallId: toolUseId,
-            sessionUpdate: "tool_call_update"
-          }
-        });
-      } else {
-        ctx.logger.error(
-          `Got a tool response for tool use that wasn't tracked: ${toolUseId}`
-        );
+  if (!alreadyCached && ctx.registerHooks !== false) {
+    registerHookCallback(chunk.id, {
+      onPostToolUseHook: async (toolUseId, _toolInput, toolResponse) => {
+        const toolUse = ctx.toolUseCache[toolUseId];
+        if (toolUse) {
+          const editUpdate = toolUse.name === "Edit" ? toolUpdateFromEditToolResponse(toolResponse) : null;
+          await ctx.client.sessionUpdate({
+            sessionId: ctx.sessionId,
+            update: {
+              _meta: toolMeta(toolUse.name, toolResponse, ctx.parentToolCallId),
+              toolCallId: toolUseId,
+              sessionUpdate: "tool_call_update",
+              ...editUpdate ? editUpdate : {}
+            }
+          });
+        } else {
+          ctx.logger.error(
+            `Got a tool response for tool use that wasn't tracked: ${toolUseId}`
+          );
+        }
       }
-    }
-  });
+    });
+  }
   let rawInput;
   try {
     rawInput = JSON.parse(JSON.stringify(chunk.input));
   } catch {
   }
+  const toolInfo = toolInfoFromToolUse(chunk, {
+    supportsTerminalOutput: ctx.supportsTerminalOutput,
+    toolUseId: chunk.id
+  });
+  const meta = {
+    ...toolMeta(chunk.name, void 0, ctx.parentToolCallId)
+  };
+  if (chunk.name === "Bash" && ctx.supportsTerminalOutput && !alreadyCached) {
+    meta.terminal_info = { terminal_id: chunk.id };
+  }
+  if (alreadyCached) {
+    return {
+      _meta: meta,
+      toolCallId: chunk.id,
+      sessionUpdate: "tool_call_update",
+      rawInput,
+      ...toolInfo
+    };
+  }
   return {
-    _meta: toolMeta(chunk.name, void 0, ctx.parentToolCallId),
+    _meta: meta,
     toolCallId: chunk.id,
     sessionUpdate: "tool_call",
     rawInput,
     status: "pending",
-    ...toolInfoFromToolUse(chunk, ctx.fileContentCache, ctx.logger)
+    ...toolInfo
   };
 }
 function handleToolResultChunk(chunk, ctx) {
@@ -2287,36 +2362,71 @@ function handleToolResultChunk(chunk, ctx) {
     ctx.logger.error(
       `Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`
     );
-    return null;
+    return [];
   }
   if (toolUse.name === "TodoWrite") {
-    return null;
+    return [];
   }
-  return {
-    _meta: toolMeta(toolUse.name, void 0, ctx.parentToolCallId),
+  const { _meta: resultMeta, ...toolUpdate } = toolUpdateFromToolResult(
+    chunk,
+    toolUse,
+    {
+      supportsTerminalOutput: ctx.supportsTerminalOutput,
+      toolUseId: chunk.tool_use_id
+    }
+  );
+  const updates = [];
+  if (resultMeta?.terminal_output) {
+    const terminalOutputMeta = {
+      terminal_output: resultMeta.terminal_output
+    };
+    if (ctx.parentToolCallId) {
+      terminalOutputMeta.claudeCode = {
+        parentToolCallId: ctx.parentToolCallId
+      };
+    }
+    updates.push({
+      _meta: terminalOutputMeta,
+      toolCallId: chunk.tool_use_id,
+      sessionUpdate: "tool_call_update"
+    });
+  }
+  const meta = {
+    ...toolMeta(toolUse.name, void 0, ctx.parentToolCallId),
+    ...resultMeta?.terminal_exit ? { terminal_exit: resultMeta.terminal_exit } : {}
+  };
+  updates.push({
+    _meta: meta,
     toolCallId: chunk.tool_use_id,
     sessionUpdate: "tool_call_update",
     status: chunk.is_error ? "failed" : "completed",
-    ...toolUpdateFromToolResult(
-      chunk,
-      toolUse
-    )
-  };
+    rawOutput: chunk.content,
+    ...toolUpdate
+  });
+  return updates;
 }
 function processContentChunk(chunk, role, ctx) {
   switch (chunk.type) {
     case "text":
-    case "text_delta":
-      return handleTextChunk(chunk, role, ctx.parentToolCallId);
-    case "image":
-      return handleImageChunk(chunk, role);
+    case "text_delta": {
+      const update = handleTextChunk(chunk, role, ctx.parentToolCallId);
+      return update ? [update] : [];
+    }
+    case "image": {
+      const update = handleImageChunk(chunk, role);
+      return update ? [update] : [];
+    }
     case "thinking":
-    case "thinking_delta":
-      return handleThinkingChunk(chunk, ctx.parentToolCallId);
+    case "thinking_delta": {
+      const update = handleThinkingChunk(chunk, ctx.parentToolCallId);
+      return update ? [update] : [];
+    }
     case "tool_use":
     case "server_tool_use":
-    case "mcp_tool_use":
-      return handleToolUseChunk(chunk, ctx);
+    case "mcp_tool_use": {
+      const update = handleToolUseChunk(chunk, ctx);
+      return update ? [update] : [];
+    }
     case "tool_result":
     case "tool_search_tool_result":
     case "web_fetch_tool_result":
@@ -2338,13 +2448,13 @@ function processContentChunk(chunk, role, ctx) {
     case "container_upload":
     case "compaction":
     case "compaction_delta":
-      return null;
+      return [];
     default:
       unreachable(chunk, ctx.logger);
-      return null;
+      return [];
   }
 }
-function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId) {
+function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput) {
   if (typeof content === "string") {
     const update = {
       sessionUpdate: messageUpdateType(role),
@@ -2365,18 +2475,19 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
     fileContentCache,
     client,
     logger,
-    parentToolCallId
+    parentToolCallId,
+    registerHooks,
+    supportsTerminalOutput
   };
   const output = [];
   for (const chunk of content) {
-    const update = processContentChunk(chunk, role, ctx);
-    if (update) {
+    for (const update of processContentChunk(chunk, role, ctx)) {
       output.push({ sessionId, update });
     }
   }
   return output;
 }
-function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId) {
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput) {
   const event = message.event;
   switch (event.type) {
     case "content_block_start":
@@ -2388,7 +2499,9 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         fileContentCache,
         client,
         logger,
-        parentToolCallId
+        parentToolCallId,
+        registerHooks,
+        supportsTerminalOutput
       );
     case "content_block_delta":
       return toAcpNotifications(
@@ -2399,7 +2512,9 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         fileContentCache,
         client,
         logger,
-        parentToolCallId
+        parentToolCallId,
+        registerHooks,
+        supportsTerminalOutput
       );
     case "message_start":
     case "message_delta":
@@ -2458,29 +2573,25 @@ async function handleSystemMessage(message, context) {
       break;
   }
 }
-function handleResultMessage(message, context) {
-  const { session } = context;
-  if (session.cancelled) {
-    return {
-      shouldStop: true,
-      stopReason: "cancelled"
-    };
-  }
+function handleResultMessage(message) {
+  const usage = extractUsageFromResult(message);
   switch (message.subtype) {
     case "success": {
       if (message.result.includes("Please run /login")) {
         return {
           shouldStop: true,
-          error: RequestError.authRequired()
+          error: RequestError.authRequired(),
+          usage
         };
       }
       if (message.is_error) {
         return {
           shouldStop: true,
-          error: RequestError.internalError(void 0, message.result)
+          error: RequestError.internalError(void 0, message.result),
+          usage
         };
       }
-      return { shouldStop: true, stopReason: "end_turn" };
+      return { shouldStop: true, stopReason: "end_turn", usage };
     }
     case "error_during_execution":
       if (message.is_error) {
@@ -2489,10 +2600,11 @@ function handleResultMessage(message, context) {
           error: RequestError.internalError(
             void 0,
             message.errors.join(", ") || message.subtype
-          )
+          ),
+          usage
         };
       }
-      return { shouldStop: true, stopReason: "end_turn" };
+      return { shouldStop: true, stopReason: "end_turn", usage };
     case "error_max_budget_usd":
     case "error_max_turns":
     case "error_max_structured_output_retries":
@@ -2502,13 +2614,37 @@ function handleResultMessage(message, context) {
           error: RequestError.internalError(
             void 0,
             message.errors.join(", ") || message.subtype
-          )
+          ),
+          usage
         };
       }
-      return { shouldStop: true, stopReason: "max_turn_requests" };
+      return { shouldStop: true, stopReason: "max_turn_requests", usage };
     default:
-      return { shouldStop: false };
+      return { shouldStop: false, usage };
+  }
+}
+function extractUsageFromResult(message) {
+  const msg = message;
+  const msgUsage = msg.usage;
+  if (!msgUsage) return void 0;
+  const modelUsage = msg.modelUsage;
+  let contextWindowSize;
+  if (modelUsage) {
+    const contextWindows = Object.values(modelUsage).map(
+      (m) => m.contextWindow
+    );
+    if (contextWindows.length > 0) {
+      contextWindowSize = Math.min(...contextWindows);
+    }
   }
+  return {
+    inputTokens: msgUsage.input_tokens ?? 0,
+    outputTokens: msgUsage.output_tokens ?? 0,
+    cachedReadTokens: msgUsage.cache_read_input_tokens ?? 0,
+    cachedWriteTokens: msgUsage.cache_creation_input_tokens ?? 0,
+    costUsd: typeof msg.total_cost_usd === "number" ? msg.total_cost_usd : void 0,
+    contextWindowSize
+  };
 }
 async function handleStreamEvent(message, context) {
   const { sessionId, client, toolUseCache, fileContentCache, logger } = context;
@@ -2520,7 +2656,9 @@ async function handleStreamEvent(message, context) {
     fileContentCache,
     client,
     logger,
-    parentToolCallId
+    parentToolCallId,
+    context.registerHooks,
+    context.supportsTerminalOutput
   )) {
     await client.sessionUpdate(notification);
     context.session.notificationHistory.push(notification);
@@ -2532,14 +2670,15 @@ function hasLocalCommandStdout(content) {
 function hasLocalCommandStderr(content) {
   return typeof content === "string" && content.includes("<local-command-stderr>");
 }
-function isSimpleUserMessage(message) {
-  return message.type === "user" && (typeof message.message.content === "string" || Array.isArray(message.message.content) && message.message.content.length === 1 && message.message.content[0].type === "text");
-}
 function isLoginRequiredMessage(message) {
   return message.type === "assistant" && message.message.model === "<synthetic>" && Array.isArray(message.message.content) && message.message.content.length === 1 && message.message.content[0].type === "text" && message.message.content[0].text?.includes("Please run /login") === true;
 }
+function isPlainTextUserMessage(message) {
+  const content = message.message.content;
+  return message.type === "user" && (typeof content === "string" || Array.isArray(content) && content.length === 1 && content[0].type === "text");
+}
 function shouldSkipUserAssistantMessage(message) {
-  return hasLocalCommandStdout(message.message.content) || hasLocalCommandStderr(message.message.content) || isSimpleUserMessage(message) || isLoginRequiredMessage(message);
+  return hasLocalCommandStdout(message.message.content) || hasLocalCommandStderr(message.message.content) || isLoginRequiredMessage(message);
 }
 function logSpecialMessages(message, logger) {
   const content = message.message.content;
@@ -2560,18 +2699,33 @@ function filterMessageContent(content) {
 }
 async function handleUserAssistantMessage(message, context) {
   const { session, sessionId, client, toolUseCache, fileContentCache, logger } = context;
-  if (session.cancelled) {
-    return {};
-  }
   if (shouldSkipUserAssistantMessage(message)) {
+    const content2 = message.message.content;
+    if (typeof content2 === "string" && hasLocalCommandStdout(content2) && content2.includes("Context Usage")) {
+      const stripped = content2.replace("<local-command-stdout>", "").replace("</local-command-stdout>", "");
+      for (const notification of toAcpNotifications(
+        stripped,
+        "assistant",
+        sessionId,
+        toolUseCache,
+        fileContentCache,
+        client,
+        logger
+      )) {
+        await client.sessionUpdate(notification);
+      }
+    }
     logSpecialMessages(message, logger);
     if (isLoginRequiredMessage(message)) {
       return { shouldStop: true, error: RequestError.authRequired() };
     }
     return {};
   }
+  if (isPlainTextUserMessage(message)) {
+    return {};
+  }
   const content = message.message.content;
-  const contentToProcess = filterMessageContent(content);
+  const contentToProcess = message.type === "assistant" ? filterMessageContent(content) : content;
   const parentToolCallId = "parent_tool_use_id" in message ? message.parent_tool_use_id ?? void 0 : void 0;
   for (const notification of toAcpNotifications(
     contentToProcess,
@@ -2581,7 +2735,9 @@ async function handleUserAssistantMessage(message, context) {
     fileContentCache,
     client,
     logger,
-    parentToolCallId
+    parentToolCallId,
+    context.registerHooks,
+    context.supportsTerminalOutput
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);
@@ -2667,36 +2823,45 @@ function normalizeAskUserQuestionInput(input) {
 }
 
 // src/execution-mode.ts
-var MODES = [
+var ALLOW_BYPASS = !IS_ROOT;
+var availableModes = [
   {
     id: "default",
-    name: "Always Ask",
-    description: "Prompts for permission on first use of each tool"
+    name: "Default",
+    description: "Standard behavior, prompts for dangerous operations"
   },
   {
     id: "acceptEdits",
     name: "Accept Edits",
-    description: "Automatically accepts file edit permissions for the session"
+    description: "Auto-accept file edit operations"
   },
   {
     id: "plan",
     name: "Plan Mode",
-    description: "Claude can analyze but not modify files or execute commands"
-  },
-  {
-    id: "bypassPermissions",
-    name: "Bypass Permissions",
-    description: "Skips all permission prompts"
+    description: "Planning mode, no actual tool execution"
   }
+  // {
+  //   id: "dontAsk",
+  //   name: "Don't Ask",
+  //   description: "Don't prompt for permissions, deny if not pre-approved",
+  // },
 ];
+if (ALLOW_BYPASS) {
+  availableModes.push({
+    id: "bypassPermissions",
+    name: "Bypass Permissions",
+    description: "Bypass all permission checks"
+  });
+}
 var TWIG_EXECUTION_MODES = [
   "default",
   "acceptEdits",
   "plan",
+  // "dontAsk",
   "bypassPermissions"
 ];
 function getAvailableModes() {
-  return IS_ROOT ? MODES.filter((m) => m.id !== "bypassPermissions") : MODES;
+  return IS_ROOT ? availableModes.filter((m) => m.id !== "bypassPermissions") : availableModes;
 }
 
 // src/adapters/claude/tools.ts
@@ -2724,6 +2889,7 @@ var AUTO_ALLOWED_TOOLS = {
   default: new Set(BASE_ALLOWED_TOOLS),
   acceptEdits: /* @__PURE__ */ new Set([...BASE_ALLOWED_TOOLS, ...WRITE_TOOLS]),
   plan: new Set(BASE_ALLOWED_TOOLS)
+  // dontAsk: new Set(BASE_ALLOWED_TOOLS),
 };
 function isToolAllowedForMode(toolName, mode) {
   if (mode === "bypassPermissions") {
@@ -2871,12 +3037,11 @@ async function validatePlanContent(planText, context) {
   return { valid: true };
 }
 async function requestPlanApproval(context, updatedInput) {
-  const { client, sessionId, toolUseID, fileContentCache } = context;
-  const toolInfo = toolInfoFromToolUse(
-    { name: context.toolName, input: updatedInput },
-    fileContentCache,
-    context.logger
-  );
+  const { client, sessionId, toolUseID } = context;
+  const toolInfo = toolInfoFromToolUse({
+    name: context.toolName,
+    input: updatedInput
+  });
   return await client.requestPermission({
     options: buildExitPlanModePermissionOptions(),
     sessionId,
@@ -2895,7 +3060,14 @@ async function applyPlanApproval(response, context, updatedInput) {
   if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")) {
     session.permissionMode = response.outcome.optionId;
     await session.query.setPermissionMode(response.outcome.optionId);
-    await context.emitConfigOptionsUpdate();
+    await context.client.sessionUpdate({
+      sessionId: context.sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: response.outcome.optionId
+      }
+    });
+    await context.updateConfigOption("mode", response.outcome.optionId);
     return {
       behavior: "allow",
       updatedInput,
@@ -2916,7 +3088,7 @@ async function handleEnterPlanModeTool(context) {
   const { session, toolInput } = context;
   session.permissionMode = "plan";
   await session.query.setPermissionMode("plan");
-  await context.emitConfigOptionsUpdate();
+  await context.updateConfigOption("mode", "plan");
   return {
     behavior: "allow",
     updatedInput: toolInput
@@ -2934,6 +3106,9 @@ async function handleExitPlanModeTool(context) {
     return validationResult.error;
   }
   const response = await requestPlanApproval(context, updatedInput);
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
   return await applyPlanApproval(response, context, updatedInput);
 }
 function buildQuestionOptions(question) {
@@ -2957,14 +3132,13 @@ async function handleAskUserQuestionTool(context) {
       interrupt: true
     };
   }
-  const { client, sessionId, toolUseID, toolInput, fileContentCache } = context;
+  const { client, sessionId, toolUseID, toolInput } = context;
   const firstQuestion = questions[0];
   const options = buildQuestionOptions(firstQuestion);
-  const toolInfo = toolInfoFromToolUse(
-    { name: context.toolName, input: toolInput },
-    fileContentCache,
-    context.logger
-  );
+  const toolInfo = toolInfoFromToolUse({
+    name: context.toolName,
+    input: toolInput
+  });
   const response = await client.requestPermission({
     options,
     sessionId,
@@ -2979,6 +3153,9 @@ async function handleAskUserQuestionTool(context) {
       }
     }
   });
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
   if (response.outcome?.outcome !== "selected") {
     const customMessage = response._meta?.message;
     return {
@@ -3011,14 +3188,9 @@ async function handleDefaultPermissionFlow(context) {
     toolUseID,
     client,
     sessionId,
-    fileContentCache,
     suggestions
   } = context;
-  const toolInfo = toolInfoFromToolUse(
-    { name: toolName, input: toolInput },
-    fileContentCache,
-    context.logger
-  );
+  const toolInfo = toolInfoFromToolUse({ name: toolName, input: toolInput });
   const options = buildPermissionOptions(
     toolName,
     toolInput,
@@ -3037,6 +3209,9 @@ async function handleDefaultPermissionFlow(context) {
       rawInput: toolInput
     }
   });
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
   if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")) {
     if (response.outcome.optionId === "allow_always") {
       return {
@@ -3113,16 +3288,18 @@ async function canUseTool(context) {
 var UNSUPPORTED_COMMANDS = [
   "context",
   "cost",
+  "keybindings-help",
   "login",
   "logout",
   "output-style:new",
   "release-notes",
   "todos"
 ];
-async function getAvailableSlashCommands(q) {
-  const commands = await q.supportedCommands();
+function getAvailableSlashCommands(commands) {
   return commands.map((command) => {
-    const input = command.argumentHint ? { hint: command.argumentHint } : null;
+    const input = command.argumentHint != null ? {
+      hint: Array.isArray(command.argumentHint) ? command.argumentHint.join(" ") : command.argumentHint
+    } : null;
     let name = command.name;
     if (command.name.endsWith(" (MCP)")) {
       name = `mcp:${name.replace(" (MCP)", "")}`;
@@ -3220,13 +3397,19 @@ function buildEnvironment() {
     ENABLE_TOOL_SEARCH: "auto:0"
   };
 }
-function buildHooks(userHooks, onModeChange) {
+function buildHooks(userHooks, onModeChange, settingsManager, logger) {
   return {
     ...userHooks,
     PostToolUse: [
       ...userHooks?.PostToolUse || [],
       {
-        hooks: [createPostToolUseHook({ onModeChange })]
+        hooks: [createPostToolUseHook({ onModeChange, logger })]
+      }
+    ],
+    PreToolUse: [
+      ...userHooks?.PreToolUse || [],
+      {
+        hooks: [createPreToolUseHook(settingsManager, logger)]
       }
     ]
   };
@@ -3320,12 +3503,22 @@ function buildSessionOptions(params) {
     permissionMode: params.permissionMode,
     canUseTool: params.canUseTool,
     executable: "node",
+    tools: { type: "preset", preset: "claude_code" },
+    extraArgs: {
+      ...params.userProvidedOptions?.extraArgs,
+      "replay-user-messages": ""
+    },
     mcpServers: buildMcpServers(
       params.userProvidedOptions?.mcpServers,
       params.mcpServers
     ),
     env: buildEnvironment(),
-    hooks: buildHooks(params.userProvidedOptions?.hooks, params.onModeChange),
+    hooks: buildHooks(
+      params.userProvidedOptions?.hooks,
+      params.onModeChange,
+      params.settingsManager,
+      params.logger
+    ),
     abortController: getAbortController(
       params.userProvidedOptions?.abortController
     ),
@@ -3342,13 +3535,36 @@ function buildSessionOptions(params) {
   }
   if (params.isResume) {
     options.resume = params.sessionId;
-    options.forkSession = false;
+    options.forkSession = params.forkSession ?? false;
   } else {
     options.sessionId = params.sessionId;
+    options.model = DEFAULT_MODEL;
   }
   if (params.additionalDirectories) {
     options.additionalDirectories = params.additionalDirectories;
   }
+  if (params.disableBuiltInTools) {
+    const builtInTools = [
+      "Read",
+      "Write",
+      "Edit",
+      "Bash",
+      "Glob",
+      "Grep",
+      "Task",
+      "TodoWrite",
+      "ExitPlanMode",
+      "WebSearch",
+      "WebFetch",
+      "SlashCommand",
+      "Skill",
+      "NotebookEdit"
+    ];
+    options.disallowedTools = [
+      ...options.disallowedTools ?? [],
+      ...builtInTools
+    ];
+  }
   clearStatsigCache();
   return options;
 }
@@ -3361,15 +3577,268 @@ function clearStatsigCache() {
   });
 }
 
+// src/adapters/claude/session/settings.ts
+import * as fs2 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+import { minimatch } from "minimatch";
+var ACP_TOOL_NAME_PREFIX = "mcp__acp__";
+var acpToolNames = {
+  read: `${ACP_TOOL_NAME_PREFIX}Read`,
+  edit: `${ACP_TOOL_NAME_PREFIX}Edit`,
+  write: `${ACP_TOOL_NAME_PREFIX}Write`,
+  bash: `${ACP_TOOL_NAME_PREFIX}Bash`
+};
+var SHELL_OPERATORS = ["&&", "||", ";", "|", "$(", "`", "\n"];
+function containsShellOperator(str) {
+  return SHELL_OPERATORS.some((op) => str.includes(op));
+}
+var FILE_EDITING_TOOLS = [acpToolNames.edit, acpToolNames.write];
+var FILE_READING_TOOLS = [acpToolNames.read];
+var TOOL_ARG_ACCESSORS = {
+  [acpToolNames.read]: (input) => input?.file_path,
+  [acpToolNames.edit]: (input) => input?.file_path,
+  [acpToolNames.write]: (input) => input?.file_path,
+  [acpToolNames.bash]: (input) => input?.command
+};
+function parseRule(rule) {
+  const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+  if (!match) {
+    return { toolName: rule };
+  }
+  const toolName = match[1] ?? rule;
+  const argument = match[2];
+  if (argument?.endsWith(":*")) {
+    return {
+      toolName,
+      argument: argument.slice(0, -2),
+      isWildcard: true
+    };
+  }
+  return { toolName, argument };
+}
+function normalizePath(filePath, cwd) {
+  let resolved = filePath;
+  if (resolved.startsWith("~/")) {
+    resolved = path3.join(os3.homedir(), resolved.slice(2));
+  } else if (resolved.startsWith("./")) {
+    resolved = path3.join(cwd, resolved.slice(2));
+  } else if (!path3.isAbsolute(resolved)) {
+    resolved = path3.join(cwd, resolved);
+  }
+  return path3.normalize(resolved).replace(/\\/g, "/");
+}
+function matchesGlob(pattern, filePath, cwd) {
+  const normalizedPattern = normalizePath(pattern, cwd);
+  const normalizedPath = normalizePath(filePath, cwd);
+  return minimatch(normalizedPath, normalizedPattern, {
+    dot: true,
+    matchBase: false,
+    nocase: process.platform === "win32"
+  });
+}
+function matchesRule(rule, toolName, toolInput, cwd) {
+  const ruleAppliesToTool = rule.toolName === "Bash" && toolName === acpToolNames.bash || rule.toolName === "Edit" && FILE_EDITING_TOOLS.includes(toolName) || rule.toolName === "Read" && FILE_READING_TOOLS.includes(toolName);
+  if (!ruleAppliesToTool) {
+    return false;
+  }
+  if (!rule.argument) {
+    return true;
+  }
+  const argAccessor = TOOL_ARG_ACCESSORS[toolName];
+  if (!argAccessor) {
+    return true;
+  }
+  const actualArg = argAccessor(toolInput);
+  if (!actualArg) {
+    return false;
+  }
+  if (toolName === acpToolNames.bash) {
+    if (rule.isWildcard) {
+      if (!actualArg.startsWith(rule.argument)) {
+        return false;
+      }
+      const remainder = actualArg.slice(rule.argument.length);
+      if (containsShellOperator(remainder)) {
+        return false;
+      }
+      return true;
+    }
+    return actualArg === rule.argument;
+  }
+  return matchesGlob(rule.argument, actualArg, cwd);
+}
+async function loadSettingsFile(filePath) {
+  if (!filePath) {
+    return {};
+  }
+  try {
+    const content = await fs2.promises.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function getManagedSettingsPath() {
+  switch (process.platform) {
+    case "darwin":
+      return "/Library/Application Support/ClaudeCode/managed-settings.json";
+    case "linux":
+      return "/etc/claude-code/managed-settings.json";
+    case "win32":
+      return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
+    default:
+      return "/etc/claude-code/managed-settings.json";
+  }
+}
+var SettingsManager = class {
+  cwd;
+  userSettings = {};
+  projectSettings = {};
+  localSettings = {};
+  enterpriseSettings = {};
+  mergedSettings = {};
+  initialized = false;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.loadAllSettings();
+    this.initialized = true;
+  }
+  getUserSettingsPath() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path3.join(os3.homedir(), ".claude");
+    return path3.join(configDir, "settings.json");
+  }
+  getProjectSettingsPath() {
+    return path3.join(this.cwd, ".claude", "settings.json");
+  }
+  getLocalSettingsPath() {
+    return path3.join(this.cwd, ".claude", "settings.local.json");
+  }
+  async loadAllSettings() {
+    const [userSettings, projectSettings, localSettings, enterpriseSettings] = await Promise.all([
+      loadSettingsFile(this.getUserSettingsPath()),
+      loadSettingsFile(this.getProjectSettingsPath()),
+      loadSettingsFile(this.getLocalSettingsPath()),
+      loadSettingsFile(getManagedSettingsPath())
+    ]);
+    this.userSettings = userSettings;
+    this.projectSettings = projectSettings;
+    this.localSettings = localSettings;
+    this.enterpriseSettings = enterpriseSettings;
+    this.mergeAllSettings();
+  }
+  mergeAllSettings() {
+    const allSettings = [
+      this.userSettings,
+      this.projectSettings,
+      this.localSettings,
+      this.enterpriseSettings
+    ];
+    const permissions = {
+      allow: [],
+      deny: [],
+      ask: []
+    };
+    const merged = { permissions };
+    for (const settings of allSettings) {
+      if (settings.permissions) {
+        if (settings.permissions.allow) {
+          permissions.allow?.push(...settings.permissions.allow);
+        }
+        if (settings.permissions.deny) {
+          permissions.deny?.push(...settings.permissions.deny);
+        }
+        if (settings.permissions.ask) {
+          permissions.ask?.push(...settings.permissions.ask);
+        }
+        if (settings.permissions.additionalDirectories) {
+          permissions.additionalDirectories = [
+            ...permissions.additionalDirectories || [],
+            ...settings.permissions.additionalDirectories
+          ];
+        }
+        if (settings.permissions.defaultMode) {
+          permissions.defaultMode = settings.permissions.defaultMode;
+        }
+      }
+      if (settings.env) {
+        merged.env = { ...merged.env, ...settings.env };
+      }
+      if (settings.model) {
+        merged.model = settings.model;
+      }
+    }
+    this.mergedSettings = merged;
+  }
+  checkPermission(toolName, toolInput) {
+    if (!toolName.startsWith(ACP_TOOL_NAME_PREFIX)) {
+      return { decision: "ask" };
+    }
+    const permissions = this.mergedSettings.permissions;
+    if (!permissions) {
+      return { decision: "ask" };
+    }
+    for (const rule of permissions.deny || []) {
+      const parsed = parseRule(rule);
+      if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+        return { decision: "deny", rule, source: "deny" };
+      }
+    }
+    for (const rule of permissions.allow || []) {
+      const parsed = parseRule(rule);
+      if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+        return { decision: "allow", rule, source: "allow" };
+      }
+    }
+    for (const rule of permissions.ask || []) {
+      const parsed = parseRule(rule);
+      if (matchesRule(parsed, toolName, toolInput, this.cwd)) {
+        return { decision: "ask", rule, source: "ask" };
+      }
+    }
+    return { decision: "ask" };
+  }
+  getSettings() {
+    return this.mergedSettings;
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  async setCwd(cwd) {
+    if (this.cwd === cwd) {
+      return;
+    }
+    this.dispose();
+    this.cwd = cwd;
+    this.initialized = false;
+    await this.initialize();
+  }
+  dispose() {
+    this.initialized = false;
+  }
+};
+
 // src/adapters/claude/claude-agent.ts
 var SESSION_VALIDATION_TIMEOUT_MS = 1e4;
+var MAX_TITLE_LENGTH = 256;
+function sanitizeTitle(text2) {
+  const sanitized = text2.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+  if (sanitized.length <= MAX_TITLE_LENGTH) {
+    return sanitized;
+  }
+  return `${sanitized.slice(0, MAX_TITLE_LENGTH - 1)}\u2026`;
+}
 var ClaudeAcpAgent = class extends BaseAcpAgent {
   adapterName = "claude";
   toolUseCache;
   backgroundTerminals = {};
   clientCapabilities;
   options;
-  lastSentConfigOptions;
   constructor(client, options) {
     super(client);
     this.options = options;
@@ -3390,125 +3859,416 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
           sse: true
         },
         loadSession: true,
+        sessionCapabilities: {
+          list: {},
+          fork: {},
+          resume: {}
+        },
         _meta: {
           posthog: {
             resumeSession: true
+          },
+          claudeCode: {
+            promptQueueing: true
+          }
+        }
+      },
+      agentInfo: {
+        name: package_default.name,
+        title: "Claude Agent",
+        version: package_default.version
+      },
+      authMethods: []
+    };
+  }
+  async newSession(params) {
+    if (fs3.existsSync(path4.resolve(os4.homedir(), ".claude.json.backup")) && !fs3.existsSync(path4.resolve(os4.homedir(), ".claude.json"))) {
+      throw RequestError2.authRequired();
+    }
+    const response = await this.createSession(params, {
+      // Revisit these meta values once we support resume
+      resume: params._meta?.claudeCode?.options?.resume
+    });
+    return response;
+  }
+  async unstable_forkSession(params) {
+    return this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      { resume: params.sessionId, forkSession: true }
+    );
+  }
+  async unstable_resumeSession(params) {
+    const response = await this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      {
+        resume: params.sessionId
+      }
+    );
+    return response;
+  }
+  async loadSession(params) {
+    const response = await this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      { resume: params.sessionId, skipBackgroundFetches: true }
+    );
+    await this.replaySessionHistory(params.sessionId);
+    this.deferBackgroundFetches(this.session.query);
+    return {
+      modes: response.modes,
+      models: response.models,
+      configOptions: response.configOptions
+    };
+  }
+  async unstable_listSessions(params) {
+    const sdkSessions = await listSessions({ dir: params.cwd ?? void 0 });
+    const sessions = [];
+    for (const session of sdkSessions) {
+      if (!session.cwd) continue;
+      sessions.push({
+        sessionId: session.sessionId,
+        cwd: session.cwd,
+        title: sanitizeTitle(session.customTitle || session.summary || ""),
+        updatedAt: new Date(session.lastModified).toISOString()
+      });
+    }
+    return {
+      sessions
+    };
+  }
+  async prompt(params) {
+    this.session.cancelled = false;
+    this.session.interruptReason = void 0;
+    this.session.accumulatedUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedReadTokens: 0,
+      cachedWriteTokens: 0
+    };
+    const userMessage = promptToClaude(params);
+    if (this.session.promptRunning) {
+      const uuid = randomUUID();
+      userMessage.uuid = uuid;
+      this.session.input.push(userMessage);
+      const order = this.session.nextPendingOrder++;
+      const cancelled = await new Promise((resolve4) => {
+        this.session.pendingMessages.set(uuid, { resolve: resolve4, order });
+      });
+      if (cancelled) {
+        return { stopReason: "cancelled" };
+      }
+    } else {
+      this.session.input.push(userMessage);
+    }
+    await this.broadcastUserMessage(params);
+    this.session.promptRunning = true;
+    let handedOff = false;
+    let lastAssistantTotalUsage = null;
+    const supportsTerminalOutput = this.clientCapabilities?._meta?.terminal_output === true;
+    const context = {
+      session: this.session,
+      sessionId: params.sessionId,
+      client: this.client,
+      toolUseCache: this.toolUseCache,
+      fileContentCache: this.fileContentCache,
+      logger: this.logger,
+      supportsTerminalOutput
+    };
+    try {
+      while (true) {
+        const { value: message, done } = await this.session.query.next();
+        if (done || !message) {
+          if (this.session.cancelled) {
+            return {
+              stopReason: "cancelled",
+              _meta: this.session.interruptReason ? { interruptReason: this.session.interruptReason } : void 0
+            };
+          }
+          break;
+        }
+        switch (message.type) {
+          case "system":
+            if (message.subtype === "compact_boundary") {
+              lastAssistantTotalUsage = 0;
+            }
+            await handleSystemMessage(message, context);
+            break;
+          case "result": {
+            if (this.session.cancelled) {
+              return { stopReason: "cancelled" };
+            }
+            this.session.accumulatedUsage.inputTokens += message.usage.input_tokens;
+            this.session.accumulatedUsage.outputTokens += message.usage.output_tokens;
+            this.session.accumulatedUsage.cachedReadTokens += message.usage.cache_read_input_tokens;
+            this.session.accumulatedUsage.cachedWriteTokens += message.usage.cache_creation_input_tokens;
+            const contextWindows = Object.values(message.modelUsage).map(
+              (m) => m.contextWindow
+            );
+            const contextWindowSize = contextWindows.length > 0 ? Math.min(...contextWindows) : 2e5;
+            if (lastAssistantTotalUsage !== null) {
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "usage_update",
+                  used: lastAssistantTotalUsage,
+                  size: contextWindowSize,
+                  cost: {
+                    amount: message.total_cost_usd,
+                    currency: "USD"
+                  }
+                }
+              });
+            }
+            await this.client.extNotification("_posthog/usage_update", {
+              sessionId: params.sessionId,
+              used: {
+                inputTokens: message.usage.input_tokens,
+                outputTokens: message.usage.output_tokens,
+                cachedReadTokens: message.usage.cache_read_input_tokens,
+                cachedWriteTokens: message.usage.cache_creation_input_tokens
+              },
+              cost: message.total_cost_usd
+            });
+            const usage = {
+              inputTokens: this.session.accumulatedUsage.inputTokens,
+              outputTokens: this.session.accumulatedUsage.outputTokens,
+              cachedReadTokens: this.session.accumulatedUsage.cachedReadTokens,
+              cachedWriteTokens: this.session.accumulatedUsage.cachedWriteTokens,
+              totalTokens: this.session.accumulatedUsage.inputTokens + this.session.accumulatedUsage.outputTokens + this.session.accumulatedUsage.cachedReadTokens + this.session.accumulatedUsage.cachedWriteTokens
+            };
+            const result = handleResultMessage(message);
+            if (result.error) throw result.error;
+            switch (message.subtype) {
+              case "error_max_budget_usd":
+              case "error_max_turns":
+              case "error_max_structured_output_retries":
+                return { stopReason: "max_turn_requests", usage };
+              default:
+                return { stopReason: "end_turn", usage };
+            }
+          }
+          case "stream_event":
+            await handleStreamEvent(message, context);
+            break;
+          case "user":
+          case "assistant": {
+            if (this.session.cancelled) {
+              break;
+            }
+            if (message.type === "user" && "uuid" in message && message.uuid) {
+              const pending = this.session.pendingMessages.get(
+                message.uuid
+              );
+              if (pending) {
+                pending.resolve(false);
+                this.session.pendingMessages.delete(message.uuid);
+                handedOff = true;
+                return { stopReason: "end_turn" };
+              }
+            }
+            if ("usage" in message.message && message.parent_tool_use_id === null) {
+              const usage = message.message.usage;
+              lastAssistantTotalUsage = usage.input_tokens + usage.output_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens;
+            }
+            const result = await handleUserAssistantMessage(message, context);
+            if (result.error) throw result.error;
+            if (result.shouldStop) {
+              return { stopReason: "end_turn" };
+            }
+            break;
           }
+          case "tool_progress":
+          case "auth_status":
+          case "tool_use_summary":
+            break;
+          default:
+            unreachable(message, this.logger);
+            break;
         }
-      },
-      agentInfo: {
-        name: package_default.name,
-        title: "Claude Code",
-        version: package_default.version
-      },
-      authMethods: [
-        {
-          id: "claude-login",
-          name: "Log in with Claude Code",
-          description: "Run `claude /login` in the terminal"
+      }
+      throw new Error("Session did not end in result");
+    } finally {
+      if (!handedOff) {
+        this.session.promptRunning = false;
+        for (const [key, pending] of this.session.pendingMessages) {
+          pending.resolve(true);
+          this.session.pendingMessages.delete(key);
         }
-      ]
-    };
+      }
+    }
   }
-  async authenticate(_params) {
-    throw new Error("Method not implemented.");
+  // Called by BaseAcpAgent#cancel() to interrupt the session
+  async interrupt() {
+    this.session.cancelled = true;
+    for (const [, pending] of this.session.pendingMessages) {
+      pending.resolve(true);
+    }
+    this.session.pendingMessages.clear();
+    await this.session.query.interrupt();
   }
-  async newSession(params) {
-    this.checkAuthStatus();
+  async unstable_setSessionModel(params) {
+    const sdkModelId = toSdkModelId(params.modelId);
+    await this.session.query.setModel(sdkModelId);
+    this.session.modelId = params.modelId;
+    await this.updateConfigOption("model", params.modelId);
+    return {};
+  }
+  async setSessionMode(params) {
+    await this.applySessionMode(params.modeId);
+    await this.updateConfigOption("mode", params.modeId);
+    return {};
+  }
+  async setSessionConfigOption(params) {
+    const option = this.session.configOptions.find(
+      (o) => o.id === params.configId
+    );
+    if (!option) {
+      throw new Error(`Unknown config option: ${params.configId}`);
+    }
+    const allValues = "options" in option && Array.isArray(option.options) ? option.options.flatMap(
+      (o) => "options" in o && Array.isArray(o.options) ? o.options : [o]
+    ) : [];
+    const validValue = allValues.find((o) => o.value === params.value);
+    if (!validValue) {
+      throw new Error(
+        `Invalid value for config option ${params.configId}: ${params.value}`
+      );
+    }
+    if (params.configId === "mode") {
+      await this.applySessionMode(params.value);
+      await this.client.sessionUpdate({
+        sessionId: this.sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          currentModeId: params.value
+        }
+      });
+    } else if (params.configId === "model") {
+      const sdkModelId = toSdkModelId(params.value);
+      await this.session.query.setModel(sdkModelId);
+      this.session.modelId = params.value;
+    }
+    this.session.configOptions = this.session.configOptions.map(
+      (o) => o.id === params.configId ? { ...o, currentValue: params.value } : o
+    );
+    return { configOptions: this.session.configOptions };
+  }
+  async updateConfigOption(configId, value) {
+    this.session.configOptions = this.session.configOptions.map(
+      (o) => o.id === configId ? { ...o, currentValue: value } : o
+    );
+    await this.client.sessionUpdate({
+      sessionId: this.sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: this.session.configOptions
+      }
+    });
+  }
+  async applySessionMode(modeId) {
+    if (!TWIG_EXECUTION_MODES.includes(modeId)) {
+      throw new Error("Invalid Mode");
+    }
+    const previousMode = this.session.permissionMode;
+    this.session.permissionMode = modeId;
+    try {
+      await this.session.query.setPermissionMode(modeId);
+    } catch (error) {
+      this.session.permissionMode = previousMode;
+      if (error instanceof Error) {
+        if (!error.message) {
+          error.message = "Invalid Mode";
+        }
+        throw error;
+      }
+      throw new Error("Invalid Mode");
+    }
+  }
+  async createSession(params, creationOpts = {}) {
+    const { cwd } = params;
+    const { resume, forkSession } = creationOpts;
+    const isResume = !!resume;
     const meta = params._meta;
     const taskId = meta?.persistence?.taskId;
-    const sessionId = uuidv7();
-    this.logger.info("Creating new session", {
+    let sessionId;
+    if (forkSession) {
+      sessionId = uuidv7();
+    } else if (isResume) {
+      sessionId = resume;
+    } else {
+      sessionId = uuidv7();
+    }
+    const input = new Pushable();
+    const settingsManager = new SettingsManager(cwd);
+    await settingsManager.initialize();
+    const mcpServers = parseMcpServers(params);
+    const systemPrompt = buildSystemPrompt(meta?.systemPrompt);
+    this.logger.info(isResume ? "Resuming session" : "Creating new session", {
       sessionId,
       taskId,
       taskRunId: meta?.taskRunId,
-      cwd: params.cwd
+      cwd
     });
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const mcpServers = parseMcpServers(params);
     const options = buildSessionOptions({
-      cwd: params.cwd,
+      cwd,
       mcpServers,
       permissionMode,
       canUseTool: this.createCanUseTool(sessionId),
       logger: this.logger,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      systemPrompt,
       userProvidedOptions: meta?.claudeCode?.options,
       sessionId,
-      isResume: false,
-      onModeChange: this.createOnModeChange(sessionId),
+      isResume,
+      forkSession,
+      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
+      disableBuiltInTools: meta?.disableBuiltInTools,
+      settingsManager,
+      onModeChange: this.createOnModeChange(),
       onProcessSpawned: this.options?.onProcessSpawned,
       onProcessExited: this.options?.onProcessExited
     });
-    const input = new Pushable();
-    options.model = DEFAULT_MODEL;
+    const abortController = options.abortController;
     const q = query({ prompt: input, options });
-    const session = this.createSession(
-      sessionId,
-      q,
+    const session = {
+      query: q,
       input,
+      cancelled: false,
+      settingsManager,
       permissionMode,
-      params.cwd,
-      options.abortController
-    );
-    session.taskRunId = meta?.taskRunId;
-    if (meta?.taskRunId) {
-      await this.client.extNotification("_posthog/sdk_session", {
-        taskRunId: meta.taskRunId,
-        sessionId,
-        adapter: "claude"
-      });
-    }
-    const modelOptions = await this.getModelConfigOptions();
-    this.deferBackgroundFetches(q, sessionId);
-    session.modelId = modelOptions.currentModelId;
-    const resolvedSdkModel = toSdkModelId(modelOptions.currentModelId);
-    if (resolvedSdkModel !== DEFAULT_MODEL) {
-      await this.trySetModel(q, modelOptions.currentModelId);
-    }
-    const configOptions = await this.buildConfigOptions(modelOptions);
-    return {
-      sessionId,
-      configOptions
-    };
-  }
-  async loadSession(params) {
-    return this.resumeSession(params);
-  }
-  async resumeSession(params) {
-    const meta = params._meta;
-    const taskId = meta?.persistence?.taskId;
-    const sessionId = meta?.sessionId;
-    if (!sessionId) {
-      throw new Error("Cannot resume session without sessionId");
-    }
-    if (this.sessionId === sessionId) {
-      return {};
-    }
-    this.logger.info("Resuming session", {
-      sessionId,
-      taskId,
-      taskRunId: meta?.taskRunId,
-      cwd: params.cwd
-    });
-    const mcpServers = parseMcpServers(params);
-    const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const { query: q, session } = await this.initializeQuery({
-      cwd: params.cwd,
-      permissionMode,
-      mcpServers,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-      userProvidedOptions: meta?.claudeCode?.options,
-      sessionId,
-      isResume: true,
-      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
-    });
-    this.logger.info("Session query initialized, awaiting resumption", {
-      sessionId,
-      taskId,
+      abortController,
+      accumulatedUsage: {
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedReadTokens: 0,
+        cachedWriteTokens: 0
+      },
+      configOptions: [],
+      promptRunning: false,
+      pendingMessages: /* @__PURE__ */ new Map(),
+      nextPendingOrder: 0,
+      // Custom properties
+      cwd,
+      notificationHistory: [],
       taskRunId: meta?.taskRunId
-    });
-    session.taskRunId = meta?.taskRunId;
+    };
+    this.session = session;
+    this.sessionId = sessionId;
+    this.logger.info(
+      isResume ? "Session query initialized, awaiting resumption" : "Session query initialized, awaiting initialization",
+      { sessionId, taskId, taskRunId: meta?.taskRunId }
+    );
     try {
       const result = await withTimeout(
         q.initializationResult(),
@@ -3516,231 +4276,181 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       );
       if (result.result === "timeout") {
         throw new Error(
-          `Session resumption timed out for sessionId=${sessionId}`
+          `Session ${isResume ? forkSession ? "fork" : "resumption" : "initialization"} timed out for sessionId=${sessionId}`
         );
       }
     } catch (err) {
-      this.logger.error("Session resumption failed", {
-        sessionId,
-        taskId,
-        taskRunId: meta?.taskRunId,
-        error: err instanceof Error ? err.message : String(err)
-      });
+      settingsManager.dispose();
+      this.logger.error(
+        isResume ? forkSession ? "Session fork failed" : "Session resumption failed" : "Session initialization failed",
+        {
+          sessionId,
+          taskId,
+          taskRunId: meta?.taskRunId,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      );
       throw err;
     }
-    this.logger.info("Session resumed successfully", {
-      sessionId,
-      taskId,
-      taskRunId: meta?.taskRunId
-    });
-    this.deferBackgroundFetches(q, sessionId);
-    const configOptions = await this.buildConfigOptions();
-    return { configOptions };
-  }
-  async prompt(params) {
-    this.session.cancelled = false;
-    this.session.interruptReason = void 0;
-    await this.broadcastUserMessage(params);
-    this.session.input.push(promptToClaude(params));
-    return this.processMessages(params.sessionId);
-  }
-  async setSessionConfigOption(params) {
-    const configId = params.configId;
-    const value = params.value;
-    if (configId === "mode") {
-      const modeId = value;
-      if (!TWIG_EXECUTION_MODES.includes(modeId)) {
-        throw new Error("Invalid Mode");
-      }
-      this.session.permissionMode = modeId;
-      await this.session.query.setPermissionMode(modeId);
-    } else if (configId === "model") {
-      await this.setModelWithFallback(this.session.query, value);
-      this.session.modelId = value;
-    } else {
-      throw new Error("Unsupported config option");
-    }
-    await this.emitConfigOptionsUpdate();
-    return { configOptions: await this.buildConfigOptions() };
-  }
-  async interruptSession() {
-    await this.session.query.interrupt();
-  }
-  async extMethod(method, params) {
-    if (method === "_posthog/session/resume") {
-      const result = await this.resumeSession(
-        params
-      );
-      return {
-        _meta: {
-          configOptions: result.configOptions
-        }
-      };
+    if (meta?.taskRunId) {
+      await this.client.extNotification("_posthog/sdk_session", {
+        taskRunId: meta.taskRunId,
+        sessionId,
+        adapter: "claude"
+      });
     }
-    throw RequestError2.methodNotFound(method);
-  }
-  createSession(sessionId, q, input, permissionMode, cwd, abortController) {
-    const session = {
-      query: q,
-      input,
-      cancelled: false,
-      permissionMode,
-      cwd,
-      notificationHistory: [],
-      abortController
+    const settingsModel = settingsManager.getSettings().model;
+    const modelOptions = await this.getModelConfigOptions();
+    const resolvedModelId = settingsModel || modelOptions.currentModelId;
+    session.modelId = resolvedModelId;
+    if (!isResume) {
+      const resolvedSdkModel = toSdkModelId(resolvedModelId);
+      if (resolvedSdkModel !== DEFAULT_MODEL) {
+        await this.session.query.setModel(resolvedSdkModel);
+      }
+    }
+    const availableModes2 = getAvailableModes();
+    const modes = {
+      currentModeId: permissionMode,
+      availableModes: availableModes2.map((mode) => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description ?? void 0
+      }))
+    };
+    const models = {
+      currentModelId: resolvedModelId,
+      availableModels: modelOptions.options.map(
+        (opt) => ({
+          modelId: opt.value,
+          name: opt.name,
+          description: opt.description
+        })
+      )
     };
-    this.session = session;
-    this.sessionId = sessionId;
-    return session;
-  }
-  async initializeQuery(config) {
-    const input = new Pushable();
-    const options = buildSessionOptions({
-      cwd: config.cwd,
-      mcpServers: config.mcpServers,
-      permissionMode: config.permissionMode,
-      canUseTool: this.createCanUseTool(config.sessionId),
-      logger: this.logger,
-      systemPrompt: config.systemPrompt,
-      userProvidedOptions: config.userProvidedOptions,
-      sessionId: config.sessionId,
-      isResume: config.isResume,
-      additionalDirectories: config.additionalDirectories,
-      onModeChange: this.createOnModeChange(config.sessionId),
-      onProcessSpawned: this.options?.onProcessSpawned,
-      onProcessExited: this.options?.onProcessExited
-    });
-    const q = query({ prompt: input, options });
-    const abortController = options.abortController;
-    const session = this.createSession(
-      config.sessionId,
-      q,
-      input,
-      config.permissionMode,
-      config.cwd,
-      abortController
+    const configOptions = this.buildConfigOptions(permissionMode, modelOptions);
+    session.configOptions = configOptions;
+    if (!creationOpts.skipBackgroundFetches) {
+      this.deferBackgroundFetches(q);
+    }
+    this.logger.info(
+      isResume ? "Session resumed successfully" : "Session created successfully",
+      {
+        sessionId,
+        taskId,
+        taskRunId: meta?.taskRunId
+      }
     );
-    return { query: q, input, session };
+    return { sessionId, modes, models, configOptions };
   }
   createCanUseTool(sessionId) {
-    return async (toolName, toolInput, { suggestions, toolUseID }) => canUseTool({
+    return async (toolName, toolInput, { suggestions, toolUseID, signal }) => canUseTool({
       session: this.session,
       toolName,
       toolInput,
       toolUseID,
       suggestions,
+      signal,
       client: this.client,
       sessionId,
       fileContentCache: this.fileContentCache,
       logger: this.logger,
-      emitConfigOptionsUpdate: () => this.emitConfigOptionsUpdate(sessionId)
+      updateConfigOption: (configId, value) => this.updateConfigOption(configId, value)
     });
   }
-  createOnModeChange(sessionId) {
+  createOnModeChange() {
     return async (newMode) => {
       if (this.session) {
         this.session.permissionMode = newMode;
       }
-      await this.emitConfigOptionsUpdate(sessionId);
+      await this.updateConfigOption("mode", newMode);
     };
   }
-  async buildConfigOptions(modelOptionsOverride) {
-    const options = [];
+  buildConfigOptions(currentModeId, modelOptions) {
     const modeOptions = getAvailableModes().map((mode) => ({
       value: mode.id,
       name: mode.name,
       description: mode.description ?? void 0
     }));
-    options.push({
-      id: "mode",
-      name: "Approval Preset",
-      type: "select",
-      currentValue: this.session.permissionMode,
-      options: modeOptions,
-      category: "mode",
-      description: "Choose an approval and sandboxing preset for your session"
-    });
-    const modelOptions = modelOptionsOverride ?? await this.getModelConfigOptions(this.session.modelId);
-    this.session.modelId = modelOptions.currentModelId;
-    options.push({
-      id: "model",
-      name: "Model",
-      type: "select",
-      currentValue: modelOptions.currentModelId,
-      options: modelOptions.options,
-      category: "model",
-      description: "Choose which model Claude should use"
-    });
-    return options;
+    return [
+      {
+        id: "mode",
+        name: "Approval Preset",
+        type: "select",
+        currentValue: currentModeId,
+        options: modeOptions,
+        category: "mode",
+        description: "Choose an approval and sandboxing preset for your session"
+      },
+      {
+        id: "model",
+        name: "Model",
+        type: "select",
+        currentValue: modelOptions.currentModelId,
+        options: modelOptions.options,
+        category: "model",
+        description: "Choose which model Claude should use"
+      }
+    ];
   }
-  async emitConfigOptionsUpdate(sessionId) {
-    const configOptions = await this.buildConfigOptions();
-    const serialized = JSON.stringify(configOptions);
-    if (this.lastSentConfigOptions && JSON.stringify(this.lastSentConfigOptions) === serialized) {
-      return;
-    }
-    this.lastSentConfigOptions = configOptions;
+  async sendAvailableCommandsUpdate() {
+    const commands = await this.session.query.supportedCommands();
     await this.client.sessionUpdate({
-      sessionId: sessionId ?? this.sessionId,
+      sessionId: this.sessionId,
       update: {
-        sessionUpdate: "config_option_update",
-        configOptions
+        sessionUpdate: "available_commands_update",
+        availableCommands: getAvailableSlashCommands(commands)
       }
     });
   }
-  checkAuthStatus() {
-    const backupExists = fs2.existsSync(
-      path3.resolve(os3.homedir(), ".claude.json.backup")
-    );
-    const configExists = fs2.existsSync(
-      path3.resolve(os3.homedir(), ".claude.json")
-    );
-    if (backupExists && !configExists) {
-      throw RequestError2.authRequired();
-    }
-  }
-  async trySetModel(q, modelId) {
-    try {
-      await this.setModelWithFallback(q, modelId);
-    } catch (err) {
-      this.logger.warn("Failed to set model", { modelId, error: err });
-    }
-  }
-  async setModelWithFallback(q, modelId) {
-    const sdkModelId = toSdkModelId(modelId);
+  async replaySessionHistory(sessionId) {
     try {
-      await q.setModel(sdkModelId);
-    } catch (err) {
-      if (sdkModelId === modelId) {
-        throw err;
+      const messages = await getSessionMessages(sessionId, {
+        dir: this.session.cwd
+      });
+      const replayContext = {
+        session: this.session,
+        sessionId,
+        client: this.client,
+        toolUseCache: this.toolUseCache,
+        fileContentCache: this.fileContentCache,
+        logger: this.logger,
+        registerHooks: false
+      };
+      for (const msg of messages) {
+        const sdkMessage = {
+          type: msg.type,
+          message: msg.message,
+          parent_tool_use_id: msg.parent_tool_use_id
+        };
+        await handleUserAssistantMessage(
+          sdkMessage,
+          replayContext
+        );
       }
-      await q.setModel(modelId);
+    } catch (err) {
+      this.logger.warn("Failed to replay session history", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }
+  // ================================
+  // EXTENSION METHODS
+  // ================================
   /**
    * Fire-and-forget: fetch slash commands and MCP tool metadata in parallel.
    * Both populate caches used later — neither is needed to return configOptions.
    */
-  deferBackgroundFetches(q, sessionId) {
+  deferBackgroundFetches(q) {
     Promise.all([
-      getAvailableSlashCommands(q),
+      new Promise((resolve4) => setTimeout(resolve4, 10)).then(
+        () => this.sendAvailableCommandsUpdate()
+      ),
       fetchMcpToolMetadata(q, this.logger)
-    ]).then(([slashCommands]) => {
-      this.sendAvailableCommandsUpdate(sessionId, slashCommands);
-    }).catch((err) => {
-      this.logger.warn("Failed to fetch deferred session data", { err });
-    });
-  }
-  sendAvailableCommandsUpdate(sessionId, availableCommands) {
-    setTimeout(() => {
-      this.client.sessionUpdate({
-        sessionId,
-        update: {
-          sessionUpdate: "available_commands_update",
-          availableCommands
-        }
-      });
-    }, 0);
+    ]).catch(
+      (err) => this.logger.error("Background fetch failed", { error: err })
+    );
   }
   async broadcastUserMessage(params) {
     for (const chunk of params.prompt) {
@@ -3755,71 +4465,6 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       this.appendNotification(params.sessionId, notification);
     }
   }
-  async processMessages(sessionId) {
-    const context = {
-      session: this.session,
-      sessionId,
-      client: this.client,
-      toolUseCache: this.toolUseCache,
-      fileContentCache: this.fileContentCache,
-      logger: this.logger
-    };
-    while (true) {
-      const { value: message, done } = await this.session.query.next();
-      if (done || !message) {
-        return this.handleSessionEnd();
-      }
-      const response = await this.handleMessage(message, context);
-      if (response) {
-        return response;
-      }
-    }
-  }
-  handleSessionEnd() {
-    if (this.session.cancelled) {
-      return {
-        stopReason: "cancelled",
-        _meta: this.session.interruptReason ? { interruptReason: this.session.interruptReason } : void 0
-      };
-    }
-    throw new Error("Session did not end in result");
-  }
-  async handleMessage(message, context) {
-    switch (message.type) {
-      case "system":
-        await handleSystemMessage(message, context);
-        return null;
-      case "result": {
-        const result = handleResultMessage(message, context);
-        if (result.error) throw result.error;
-        if (result.shouldStop) {
-          return {
-            stopReason: result.stopReason
-          };
-        }
-        return null;
-      }
-      case "stream_event":
-        await handleStreamEvent(message, context);
-        return null;
-      case "user":
-      case "assistant": {
-        const result = await handleUserAssistantMessage(message, context);
-        if (result.error) throw result.error;
-        if (result.shouldStop) {
-          return { stopReason: "end_turn" };
-        }
-        return null;
-      }
-      case "tool_progress":
-      case "auth_status":
-      case "tool_use_summary":
-        return null;
-      default:
-        unreachable(message, this.logger);
-        return null;
-    }
-  }
 };
 
 // src/adapters/codex/spawn.ts
@@ -4446,8 +5091,8 @@ var PostHogAPIClient = class {
 };
 
 // src/session-log-writer.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -4485,13 +5130,13 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path4.join(
+      const sessionDir = path5.join(
         this.localCachePath,
         "sessions",
         context.runId
       );
       try {
-        fs3.mkdirSync(sessionDir, { recursive: true });
+        fs4.mkdirSync(sessionDir, { recursive: true });
       } catch (error) {
         this.logger.warn("Failed to create local cache directory", {
           sessionDir,
@@ -4688,14 +5333,14 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path4.join(
+    const logPath = path5.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
       "logs.ndjson"
     );
     try {
-      fs3.appendFileSync(logPath, `${JSON.stringify(entry)}
+      fs4.appendFileSync(logPath, `${JSON.stringify(entry)}
 `);
     } catch (error) {
       this.logger.warn("Failed to write to local cache", {
@@ -4709,8 +5354,8 @@ var SessionLogWriter = class _SessionLogWriter {
 };
 
 // ../git/dist/queries.js
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -4719,7 +5364,7 @@ var import_promise_deferred = __toESM(require_dist2(), 1);
 var import_promise_deferred2 = __toESM(require_dist2(), 1);
 import { Buffer as Buffer2 } from "buffer";
 import { spawn as spawn3 } from "child_process";
-import { normalize } from "path";
+import { normalize as normalize2 } from "path";
 import { EventEmitter } from "events";
 var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -4749,8 +5394,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path8) {
-  return path8 instanceof String && cache.has(path8);
+function isPathSpec(path9) {
+  return path9 instanceof String && cache.has(path9);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -4839,8 +5484,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path8) {
-  return (0, import_file_exists.exists)(path8, import_file_exists.FOLDER);
+function folderExists(path9) {
+  return (0, import_file_exists.exists)(path9, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -5244,8 +5889,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path8) {
-      return /^\.(git)?$/.test(path8.trim());
+    parser(path9) {
+      return /^\.(git)?$/.test(path9.trim());
     }
   };
 }
@@ -5679,11 +6324,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path8, line, preview] = input.split(NULL);
-    paths.add(path8);
-    (results[path8] = results[path8] || []).push({
+    const [path9, line, preview] = input.split(NULL);
+    paths.add(path9);
+    (results[path9] = results[path9] || []).push({
       line: asNumber(line),
-      path: path8,
+      path: path9,
       preview
     });
   });
@@ -6448,14 +7093,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path8, text2) {
+function parseInit(bare, path9, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path8, false, result[1]);
+    return new InitSummary(bare, path9, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path8, true, result[1]);
+    return new InitSummary(bare, path9, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -6466,7 +7111,7 @@ function parseInit(bare, path8, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path8, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path9, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -6475,9 +7120,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path8, existing, gitDir) {
+      constructor(bare, path9, existing, gitDir) {
         this.bare = bare;
-        this.path = path8;
+        this.path = path9;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -6489,7 +7134,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path8, customArgs) {
+function initTask(bare = false, path9, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -6498,7 +7143,7 @@ function initTask(bare = false, path8, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path8, text2);
+      return parseInit(commands.includes("--bare"), path9, text2);
     }
   };
 }
@@ -7314,12 +7959,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path8, index, working_dir) {
-        this.path = path8;
+      constructor(path9, index, working_dir) {
+        this.path = path9;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path8) || [null, path8, path8];
+          const detail = fromPathRegex.exec(path9) || [null, path9, path9];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -7350,14 +7995,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path8) {
+  function data(index, workingDir, path9) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path8);
+      handler(result, path9);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path8, index, workingDir));
+      result.files.push(new FileStatusSummary(path9, index, workingDir));
     }
   }
 }
@@ -7670,9 +8315,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path8, write) {
+      hashObject(path9, write) {
         return this._runTask(
-          hashObjectTask(path8, write === true),
+          hashObjectTask(path9, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -8025,8 +8670,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path8 = input.trim().replace(/^["']|["']$/g, "");
-  return path8 && normalize(path8);
+  const path9 = input.trim().replace(/^["']|["']$/g, "");
+  return path9 && normalize2(path9);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -8340,8 +8985,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path8) {
-  return subModuleTask(["add", repo, path8]);
+function addSubModuleTask(repo, path9) {
+  return subModuleTask(["add", repo, path9]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -8671,8 +9316,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path8, then) {
-      return this._runTask(addSubModuleTask2(repo, path8), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path9, then) {
+      return this._runTask(addSubModuleTask2(repo, path9), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -9273,22 +9918,22 @@ function createGitClient(baseDir, options) {
 
 // ../git/dist/lock-detector.js
 import { execFile } from "child_process";
-import fs4 from "fs/promises";
-import path5 from "path";
+import fs5 from "fs/promises";
+import path6 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 async function getIndexLockPath(repoPath) {
   try {
     const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "index.lock"], { cwd: repoPath });
-    return path5.resolve(repoPath, stdout.trim());
+    return path6.resolve(repoPath, stdout.trim());
   } catch {
-    return path5.join(repoPath, ".git", "index.lock");
+    return path6.join(repoPath, ".git", "index.lock");
   }
 }
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat = await fs4.stat(lockPath);
+    const stat = await fs5.stat(lockPath);
     return {
       path: lockPath,
       ageMs: Date.now() - stat.mtimeMs
@@ -9299,7 +9944,7 @@ async function getLockInfo(repoPath) {
 }
 async function removeLock(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
-  await fs4.rm(lockPath, { force: true });
+  await fs5.rm(lockPath, { force: true });
 }
 async function isLocked(repoPath) {
   return await getLockInfo(repoPath) !== null;
@@ -9466,7 +10111,7 @@ async function getHeadSha(baseDir, options) {
 
 // src/sagas/apply-snapshot-saga.ts
 import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // ../shared/dist/index.js
 var consoleLogger = {
@@ -9597,8 +10242,8 @@ var Saga = class {
 
 // ../git/dist/sagas/tree.js
 import { existsSync as existsSync4 } from "fs";
-import * as fs6 from "fs/promises";
-import * as path7 from "path";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
 import * as tar from "tar";
 
 // ../git/dist/git-saga.js
@@ -9624,14 +10269,14 @@ var CaptureTreeSaga = class extends GitSaga {
   tempIndexPath = null;
   async executeGitOperations(input) {
     const { baseDir, lastTreeHash, archivePath, signal } = input;
-    const tmpDir = path7.join(baseDir, ".git", "twig-tmp");
+    const tmpDir = path8.join(baseDir, ".git", "twig-tmp");
     await this.step({
       name: "create_tmp_dir",
-      execute: () => fs6.mkdir(tmpDir, { recursive: true }),
+      execute: () => fs7.mkdir(tmpDir, { recursive: true }),
       rollback: async () => {
       }
     });
-    this.tempIndexPath = path7.join(tmpDir, `index-${Date.now()}`);
+    this.tempIndexPath = path8.join(tmpDir, `index-${Date.now()}`);
     const tempIndexGit = this.git.env({
       ...process.env,
       GIT_INDEX_FILE: this.tempIndexPath
@@ -9641,7 +10286,7 @@ var CaptureTreeSaga = class extends GitSaga {
       execute: () => tempIndexGit.raw(["read-tree", "HEAD"]),
       rollback: async () => {
         if (this.tempIndexPath) {
-          await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
+          await fs7.rm(this.tempIndexPath, { force: true }).catch(() => {
           });
         }
       }
@@ -9650,7 +10295,7 @@ var CaptureTreeSaga = class extends GitSaga {
     const treeHash = await this.readOnlyStep("write_tree", () => tempIndexGit.raw(["write-tree"]));
     if (lastTreeHash && treeHash === lastTreeHash) {
       this.log.debug("No changes since last capture", { treeHash });
-      await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
+      await fs7.rm(this.tempIndexPath, { force: true }).catch(() => {
       });
       return { snapshot: null, changed: false };
     }
@@ -9662,7 +10307,7 @@ var CaptureTreeSaga = class extends GitSaga {
       }
     });
     const changes = await this.readOnlyStep("get_changes", () => this.getChanges(this.git, baseCommit, treeHash));
-    await fs6.rm(this.tempIndexPath, { force: true }).catch(() => {
+    await fs7.rm(this.tempIndexPath, { force: true }).catch(() => {
     });
     const snapshot = {
       treeHash,
@@ -9686,15 +10331,15 @@ var CaptureTreeSaga = class extends GitSaga {
     if (filesToArchive.length === 0) {
       return void 0;
     }
-    const existingFiles = filesToArchive.filter((f) => existsSync4(path7.join(baseDir, f)));
+    const existingFiles = filesToArchive.filter((f) => existsSync4(path8.join(baseDir, f)));
     if (existingFiles.length === 0) {
       return void 0;
     }
     await this.step({
       name: "create_archive",
       execute: async () => {
-        const archiveDir = path7.dirname(archivePath);
-        await fs6.mkdir(archiveDir, { recursive: true });
+        const archiveDir = path8.dirname(archivePath);
+        await fs7.mkdir(archiveDir, { recursive: true });
         await tar.create({
           gzip: true,
           file: archivePath,
@@ -9702,7 +10347,7 @@ var CaptureTreeSaga = class extends GitSaga {
         }, existingFiles);
       },
       rollback: async () => {
-        await fs6.rm(archivePath, { force: true }).catch(() => {
+        await fs7.rm(archivePath, { force: true }).catch(() => {
         });
       }
     });
@@ -9801,9 +10446,9 @@ var ApplyTreeSaga = class extends GitSaga {
       const filesToExtract = changes.filter((c) => c.status !== "D").map((c) => c.path);
       await this.readOnlyStep("backup_existing_files", async () => {
         for (const filePath of filesToExtract) {
-          const fullPath = path7.join(baseDir, filePath);
+          const fullPath = path8.join(baseDir, filePath);
           try {
-            const content = await fs6.readFile(fullPath);
+            const content = await fs7.readFile(fullPath);
             this.fileBackups.set(filePath, content);
           } catch {
           }
@@ -9820,16 +10465,16 @@ var ApplyTreeSaga = class extends GitSaga {
         },
         rollback: async () => {
           for (const filePath of this.extractedFiles) {
-            const fullPath = path7.join(baseDir, filePath);
+            const fullPath = path8.join(baseDir, filePath);
             const backup = this.fileBackups.get(filePath);
             if (backup) {
-              const dir = path7.dirname(fullPath);
-              await fs6.mkdir(dir, { recursive: true }).catch(() => {
+              const dir = path8.dirname(fullPath);
+              await fs7.mkdir(dir, { recursive: true }).catch(() => {
               });
-              await fs6.writeFile(fullPath, backup).catch(() => {
+              await fs7.writeFile(fullPath, backup).catch(() => {
               });
             } else {
-              await fs6.rm(fullPath, { force: true }).catch(() => {
+              await fs7.rm(fullPath, { force: true }).catch(() => {
               });
             }
           }
@@ -9837,10 +10482,10 @@ var ApplyTreeSaga = class extends GitSaga {
       });
     }
     for (const change of changes.filter((c) => c.status === "D")) {
-      const fullPath = path7.join(baseDir, change.path);
+      const fullPath = path8.join(baseDir, change.path);
       const backupContent = await this.readOnlyStep(`backup_${change.path}`, async () => {
         try {
-          return await fs6.readFile(fullPath);
+          return await fs7.readFile(fullPath);
         } catch {
           return null;
         }
@@ -9848,15 +10493,15 @@ var ApplyTreeSaga = class extends GitSaga {
       await this.step({
         name: `delete_${change.path}`,
         execute: async () => {
-          await fs6.rm(fullPath, { force: true });
+          await fs7.rm(fullPath, { force: true });
           this.log.debug(`Deleted file: ${change.path}`);
         },
         rollback: async () => {
           if (backupContent) {
-            const dir = path7.dirname(fullPath);
-            await fs6.mkdir(dir, { recursive: true }).catch(() => {
+            const dir = path8.dirname(fullPath);
+            await fs7.mkdir(dir, { recursive: true }).catch(() => {
             });
-            await fs6.writeFile(fullPath, backupContent).catch(() => {
+            await fs7.writeFile(fullPath, backupContent).catch(() => {
             });
           }
         }
@@ -9878,7 +10523,7 @@ var ApplySnapshotSaga = class extends Saga {
   archivePath = null;
   async execute(input) {
     const { snapshot, repositoryPath, apiClient, taskId, runId } = input;
-    const tmpDir = join5(repositoryPath, ".posthog", "tmp");
+    const tmpDir = join6(repositoryPath, ".posthog", "tmp");
     if (!snapshot.archiveUrl) {
       throw new Error("Cannot apply snapshot: no archive URL");
     }
@@ -9889,7 +10534,7 @@ var ApplySnapshotSaga = class extends Saga {
       rollback: async () => {
       }
     });
-    const archivePath = join5(tmpDir, `${snapshot.treeHash}.tar.gz`);
+    const archivePath = join6(tmpDir, `${snapshot.treeHash}.tar.gz`);
     this.archivePath = archivePath;
     await this.step({
       name: "download_archive",
@@ -9938,7 +10583,7 @@ var ApplySnapshotSaga = class extends Saga {
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync5 } from "fs";
 import { readFile as readFile3, rm as rm4 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   async execute(input) {
     const {
@@ -9949,14 +10594,14 @@ var CaptureTreeSaga2 = class extends Saga {
       taskId,
       runId
     } = input;
-    const tmpDir = join6(repositoryPath, ".posthog", "tmp");
-    if (existsSync5(join6(repositoryPath, ".gitmodules"))) {
+    const tmpDir = join7(repositoryPath, ".posthog", "tmp");
+    if (existsSync5(join7(repositoryPath, ".gitmodules"))) {
       this.log.warn(
         "Repository has submodules - snapshot may not capture submodule state"
       );
     }
     const shouldArchive = !!apiClient;
-    const archivePath = shouldArchive ? join6(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
+    const archivePath = shouldArchive ? join7(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
     const gitCaptureSaga = new CaptureTreeSaga(this.log);
     const captureResult = await gitCaptureSaga.run({
       baseDir: repositoryPath,