@posthog/agent 2.1.125 → 2.1.137

package/dist/agent.js

@@ -262,13 +262,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";
@@ -276,7 +279,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.125",
+  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: {
@@ -352,7 +355,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",
@@ -373,6 +375,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",
@@ -406,7 +409,7 @@ function unreachable(value, logger) {
   try {
     valueAsString = JSON.stringify(value);
   } catch {
-    valueAsString = value;
+    valueAsString = String(value);
   }
   logger.error(`Unexpected case: ${valueAsString}`);
 }
@@ -514,19 +517,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", {
@@ -701,8 +705,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path5, oldText, newText) {
-    this.items.push({ type: "diff", path: path5, oldText, newText });
+  diff(path6, oldText, newText) {
+    this.items.push({ type: "diff", path: path6, oldText, newText });
     return this;
   }
   build() {
@@ -722,7 +726,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") {
@@ -737,11 +741,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();
@@ -818,79 +865,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) {
@@ -915,6 +890,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",
@@ -935,11 +917,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}`,
@@ -961,39 +943,21 @@ function toolInfoFromToolUse(toolUse, cachedFileContent, logger = new Logger({ d
         locations: []
       };
     case "Edit": {
-      const path5 = 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 (path5 && oldText) {
-        try {
-          const oldContent = cachedFileContent[path5] || "";
-          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 path6 = 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: path5 ? `Edit \`${path5}\`` : "Edit",
+        title: path6 ? `Edit \`${path6}\`` : "Edit",
         kind: "edit",
-        content: input && path5 ? [
+        content: input && path6 ? [
           {
             type: "diff",
-            path: path5,
+            path: path6,
             oldText,
             newText
           }
         ] : [],
-        locations: path5 ? affectedLines.length > 0 ? affectedLines.map((line) => ({ line, path: path5 })) : [{ path: path5 }] : []
+        locations: path6 ? [{ path: path6 }] : []
       };
     }
     case "Write": {
@@ -1047,10 +1011,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:
@@ -1069,7 +1033,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)}`;
       }
@@ -1163,7 +1129,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) {
@@ -1180,6 +1188,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
@@ -1195,18 +1213,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" };
     }
@@ -1366,6 +1417,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;
@@ -1377,37 +1429,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) {
@@ -1416,36 +1491,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":
@@ -1467,13 +1577,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),
@@ -1494,18 +1604,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":
@@ -1517,7 +1628,9 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         fileContentCache,
         client,
         logger,
-        parentToolCallId
+        parentToolCallId,
+        registerHooks,
+        supportsTerminalOutput
       );
     case "content_block_delta":
       return toAcpNotifications(
@@ -1528,7 +1641,9 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         fileContentCache,
         client,
         logger,
-        parentToolCallId
+        parentToolCallId,
+        registerHooks,
+        supportsTerminalOutput
       );
     case "message_start":
     case "message_delta":
@@ -1587,29 +1702,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) {
@@ -1618,10 +1729,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":
@@ -1631,13 +1743,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;
@@ -1649,7 +1785,9 @@ async function handleStreamEvent(message, context) {
     fileContentCache,
     client,
     logger,
-    parentToolCallId
+    parentToolCallId,
+    context.registerHooks,
+    context.supportsTerminalOutput
   )) {
     await client.sessionUpdate(notification);
     context.session.notificationHistory.push(notification);
@@ -1661,14 +1799,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;
@@ -1689,18 +1828,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,
@@ -1710,7 +1864,9 @@ async function handleUserAssistantMessage(message, context) {
     fileContentCache,
     client,
     logger,
-    parentToolCallId
+    parentToolCallId,
+    context.registerHooks,
+    context.supportsTerminalOutput
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);
@@ -1796,36 +1952,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
@@ -1853,6 +2018,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") {
@@ -2000,12 +2166,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,
@@ -2024,7 +2189,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,
@@ -2045,7 +2217,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
@@ -2063,6 +2235,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) {
@@ -2086,14 +2261,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,
@@ -2108,6 +2282,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 {
@@ -2140,14 +2317,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,
@@ -2166,6 +2338,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 {
@@ -2242,16 +2417,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)", "")}`;
@@ -2349,13 +2526,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)]
       }
     ]
   };
@@ -2449,12 +2632,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
     ),
@@ -2471,13 +2664,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;
 }
@@ -2490,154 +2706,698 @@ function clearStatsigCache() {
   });
 }
 
-// src/adapters/claude/claude-agent.ts
-var SESSION_VALIDATION_TIMEOUT_MS = 1e4;
-var ClaudeAcpAgent = class extends BaseAcpAgent {
-  adapterName = "claude";
-  toolUseCache;
-  backgroundTerminals = {};
-  clientCapabilities;
-  options;
-  lastSentConfigOptions;
-  constructor(client, options) {
-    super(client);
-    this.options = options;
-    this.toolUseCache = {};
-    this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
-  }
-  async initialize(request) {
-    this.clientCapabilities = request.clientCapabilities;
+// 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 {
-      protocolVersion: 1,
-      agentCapabilities: {
-        promptCapabilities: {
-          image: true,
-          embeddedContext: true
-        },
-        mcpCapabilities: {
-          http: true,
-          sse: true
-        },
-        loadSession: true,
-        _meta: {
-          posthog: {
-            resumeSession: true
-          }
-        }
-      },
-      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"
-        }
-      ]
+      toolName,
+      argument: argument.slice(0, -2),
+      isWildcard: true
     };
   }
-  async authenticate(_params) {
-    throw new Error("Method not implemented.");
+  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;
   }
-  async newSession(params) {
-    this.checkAuthStatus();
-    const meta = params._meta;
-    const taskId = meta?.persistence?.taskId;
-    const sessionId = uuidv7();
-    this.logger.info("Creating new session", {
-      sessionId,
-      taskId,
-      taskRunId: meta?.taskRunId,
-      cwd: params.cwd
-    });
-    const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
-    const mcpServers = parseMcpServers(params);
-    const options = buildSessionOptions({
-      cwd: params.cwd,
-      mcpServers,
-      permissionMode,
-      canUseTool: this.createCanUseTool(sessionId),
-      logger: this.logger,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
-      userProvidedOptions: meta?.claudeCode?.options,
-      sessionId,
-      isResume: false,
-      onModeChange: this.createOnModeChange(sessionId),
-      onProcessSpawned: this.options?.onProcessSpawned,
-      onProcessExited: this.options?.onProcessExited
+  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;
+  constructor(client, options) {
+    super(client);
+    this.options = options;
+    this.toolUseCache = {};
+    this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
+  }
+  async initialize(request) {
+    this.clientCapabilities = request.clientCapabilities;
+    return {
+      protocolVersion: 1,
+      agentCapabilities: {
+        promptCapabilities: {
+          image: true,
+          embeddedContext: true
+        },
+        mcpCapabilities: {
+          http: true,
+          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
     });
-    const input = new Pushable();
-    options.model = DEFAULT_MODEL;
-    const q = query({ prompt: input, options });
-    const session = this.createSession(
-      sessionId,
-      q,
-      input,
-      permissionMode,
-      params.cwd,
-      options.abortController
+    return response;
+  }
+  async unstable_forkSession(params) {
+    return this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        _meta: params._meta
+      },
+      { resume: params.sessionId, forkSession: true }
     );
-    session.taskRunId = meta?.taskRunId;
-    if (meta?.taskRunId) {
-      await this.client.extNotification("_posthog/sdk_session", {
-        taskRunId: meta.taskRunId,
-        sessionId,
-        adapter: "claude"
+  }
+  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()
       });
     }
-    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
+      sessions
     };
   }
-  async loadSession(params) {
-    return this.resumeSession(params);
+  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((resolve3) => {
+        this.session.pendingMessages.set(uuid, { resolve: resolve3, 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;
+        }
+      }
+      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);
+        }
+      }
+    }
+  }
+  // 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 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 resumeSession(params) {
+  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 = meta?.sessionId;
-    if (!sessionId) {
-      throw new Error("Cannot resume session without sessionId");
-    }
-    if (this.sessionId === sessionId) {
-      return {};
+    let sessionId;
+    if (forkSession) {
+      sessionId = uuidv7();
+    } else if (isResume) {
+      sessionId = resume;
+    } else {
+      sessionId = uuidv7();
     }
-    this.logger.info("Resuming session", {
+    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 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,
+    const options = buildSessionOptions({
+      cwd,
       mcpServers,
-      systemPrompt: buildSystemPrompt(meta?.systemPrompt),
+      permissionMode,
+      canUseTool: this.createCanUseTool(sessionId),
+      logger: this.logger,
+      systemPrompt,
       userProvidedOptions: meta?.claudeCode?.options,
       sessionId,
-      isResume: true,
-      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
+      isResume,
+      forkSession,
+      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
+      disableBuiltInTools: meta?.disableBuiltInTools,
+      settingsManager,
+      onModeChange: this.createOnModeChange(),
+      onProcessSpawned: this.options?.onProcessSpawned,
+      onProcessExited: this.options?.onProcessExited
     });
-    this.logger.info("Session query initialized, awaiting resumption", {
-      sessionId,
-      taskId,
+    const abortController = options.abortController;
+    const q = query({ prompt: input, options });
+    const session = {
+      query: q,
+      input,
+      cancelled: false,
+      settingsManager,
+      permissionMode,
+      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(),
@@ -2645,231 +3405,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");
+    if (meta?.taskRunId) {
+      await this.client.extNotification("_posthog/sdk_session", {
+        taskRunId: meta.taskRunId,
+        sessionId,
+        adapter: "claude"
+      });
     }
-    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
-        }
-      };
+    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);
+      }
     }
-    throw RequestError2.methodNotFound(method);
-  }
-  createSession(sessionId, q, input, permissionMode, cwd, abortController) {
-    const session = {
-      query: q,
-      input,
-      cancelled: false,
-      permissionMode,
-      cwd,
-      notificationHistory: [],
-      abortController
+    const availableModes2 = getAvailableModes();
+    const modes = {
+      currentModeId: permissionMode,
+      availableModes: availableModes2.map((mode) => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description ?? void 0
+      }))
     };
-    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 models = {
+      currentModelId: resolvedModelId,
+      availableModels: modelOptions.options.map(
+        (opt) => ({
+          modelId: opt.value,
+          name: opt.name,
+          description: opt.description
+        })
+      )
+    };
+    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((resolve3) => setTimeout(resolve3, 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) {
@@ -2884,71 +3594,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
@@ -3575,8 +4220,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;
@@ -3588,7 +4233,6 @@ var SessionLogWriter = class _SessionLogWriter {
   lastFlushAttemptTime = /* @__PURE__ */ new Map();
   retryCounts = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
-  messageCounts = /* @__PURE__ */ new Map();
   logger;
   localCachePath;
   constructor(options = {}) {
@@ -3598,19 +4242,6 @@ var SessionLogWriter = class _SessionLogWriter {
   }
   async flushAll() {
     const sessionIds = [...this.sessions.keys()];
-    const pendingCounts = sessionIds.map((id) => {
-      const session = this.sessions.get(id);
-      return {
-        taskId: session?.context.taskId,
-        runId: session?.context.runId,
-        pending: this.pendingEntries.get(id)?.length ?? 0,
-        messages: this.messageCounts.get(id) ?? 0
-      };
-    });
-    this.logger.info("flushAll called", {
-      sessions: sessionIds.length,
-      pending: pendingCounts
-    });
     const flushPromises = [];
     for (const sessionId of sessionIds) {
       flushPromises.push(this.flush(sessionId));
@@ -3628,13 +4259,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,
@@ -3654,15 +4285,6 @@ var SessionLogWriter = class _SessionLogWriter {
       });
       return;
     }
-    const count = (this.messageCounts.get(sessionId) ?? 0) + 1;
-    this.messageCounts.set(sessionId, count);
-    if (count % 10 === 1) {
-      this.logger.info("Messages received", {
-        count,
-        taskId: session.context.taskId,
-        runId: session.context.runId
-      });
-    }
     try {
       const message = JSON.parse(line);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -3711,12 +4333,6 @@ var SessionLogWriter = class _SessionLogWriter {
     this.emitCoalescedMessage(sessionId, session);
     const pending = this.pendingEntries.get(sessionId);
     if (!this.posthogAPI || !pending?.length) {
-      this.logger.info("flush: nothing to persist", {
-        taskId: session.context.taskId,
-        runId: session.context.runId,
-        hasPosthogAPI: !!this.posthogAPI,
-        pendingCount: pending?.length ?? 0
-      });
       return;
     }
     this.pendingEntries.delete(sessionId);
@@ -3733,11 +4349,6 @@ var SessionLogWriter = class _SessionLogWriter {
         pending
       );
       this.retryCounts.set(sessionId, 0);
-      this.logger.info("Flushed session logs", {
-        taskId: session.context.taskId,
-        runId: session.context.runId,
-        entryCount: pending.length
-      });
     } catch (error) {
       const retryCount = (this.retryCounts.get(sessionId) ?? 0) + 1;
       this.retryCounts.set(sessionId, retryCount);
@@ -3851,14 +4462,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", {