@posthog/agent 2.3.508 → 2.3.513

package/dist/agent.js

@@ -63,11 +63,11 @@ var require_tree_sitter = __commonJS({
               throw toThrow;
             };
             var scriptDirectory = "";
-            function locateFile(path15) {
+            function locateFile(path16) {
               if (Module["locateFile"]) {
-                return Module["locateFile"](path15, scriptDirectory);
+                return Module["locateFile"](path16, scriptDirectory);
               }
-              return scriptDirectory + path15;
+              return scriptDirectory + path16;
             }
             var readAsync, readBinary;
             if (ENVIRONMENT_IS_NODE) {
@@ -2588,8 +2588,8 @@ var require_tree_sitter = __commonJS({
                 } else {
                   const url = input;
                   if (typeof process !== "undefined" && process.versions && process.versions.node) {
-                    const fs11 = __require("fs");
-                    bytes = Promise.resolve(fs11.readFileSync(url));
+                    const fs12 = __require("fs");
+                    bytes = Promise.resolve(fs12.readFileSync(url));
                   } else {
                     bytes = fetch(url).then((response) => response.arrayBuffer().then((buffer) => {
                       if (response.ok) {
@@ -3400,7 +3400,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os6 = __require("os");
+    var os7 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -3448,7 +3448,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os7.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -3696,10 +3696,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(path15, isFile2, isDirectory) {
-      log(`checking %s`, path15);
+    function check(path16, isFile2, isDirectory) {
+      log(`checking %s`, path16);
       try {
-        const stat2 = fs_1.statSync(path15);
+        const stat2 = fs_1.statSync(path16);
         if (stat2.isFile() && isFile2) {
           log(`[OK] path represents a file`);
           return true;
@@ -3719,8 +3719,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path15, type = exports2.READABLE) {
-      return check(path15, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
+    function exists2(path16, type = exports2.READABLE) {
+      return check(path16, (type & exports2.FILE) > 0, (type & exports2.FOLDER) > 0);
     }
     exports2.exists = exists2;
     exports2.FILE = 1;
@@ -4014,9 +4014,9 @@ function nodeWritableToWebWritable(nodeStream) {
 
 // src/adapters/claude/claude-agent.ts
 import { randomUUID } from "crypto";
-import * as fs8 from "fs";
-import * as os4 from "os";
-import * as path12 from "path";
+import * as fs9 from "fs";
+import * as os5 from "os";
+import * as path13 from "path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -4030,7 +4030,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.508",
+  version: "2.3.513",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8669,8 +8669,8 @@ var ToolContentBuilder = class {
     this.items.push({ type: "content", content: image(data, mimeType, uri) });
     return this;
   }
-  diff(path15, oldText, newText) {
-    this.items.push({ type: "diff", path: path15, oldText, newText });
+  diff(path16, oldText, newText) {
+    this.items.push({ type: "diff", path: path16, oldText, newText });
     return this;
   }
   build() {
@@ -8681,6 +8681,54 @@ function toolContent() {
   return new ToolContentBuilder();
 }
 
+// src/utils/partial-json.ts
+function tryParsePartialJson(s) {
+  const trimmed2 = s.trim();
+  if (!trimmed2) return null;
+  try {
+    return JSON.parse(trimmed2);
+  } catch {
+  }
+  const closers = [];
+  let inString = false;
+  let escaped = false;
+  for (let i2 = 0; i2 < trimmed2.length; i2++) {
+    const ch = trimmed2[i2];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") closers.push("}");
+    else if (ch === "[") closers.push("]");
+    else if (ch === "}" || ch === "]") closers.pop();
+  }
+  const closeBrackets = (str) => {
+    let out2 = str;
+    for (let i2 = closers.length - 1; i2 >= 0; i2--) out2 += closers[i2];
+    return out2;
+  };
+  const candidates = [];
+  const closedString = inString ? `${trimmed2}"` : trimmed2;
+  candidates.push(closeBrackets(closedString));
+  let stripped = closedString.replace(/[,:]\s*$/, "");
+  stripped = stripped.replace(/,?\s*"[^"]*"\s*:?\s*$/, "");
+  candidates.push(closeBrackets(stripped));
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+
 // src/adapters/claude/permissions/posthog-exec-gate.ts
 var POSTHOG_EXEC_TOOL_RE = /^mcp__posthog(?:_[^_]+)*__exec$/;
 var POSTHOG_CALL_COMMAND_RE = /^\s*call\s+(?:--json\s+)?([a-zA-Z0-9_-]+)/;
@@ -9847,12 +9895,19 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
   }
   return output;
 }
-function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, enrichedReadCache) {
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, toolUseStreamCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, enrichedReadCache) {
   const event = message.event;
   switch (event.type) {
-    case "content_block_start":
+    case "content_block_start": {
+      const block = event.content_block;
+      if (block.type === "tool_use" || block.type === "mcp_tool_use") {
+        toolUseStreamCache.set(event.index, {
+          toolUseId: block.id,
+          partialJson: ""
+        });
+      }
       return toAcpNotifications(
-        [event.content_block],
+        [block],
         "assistant",
         sessionId,
         toolUseCache,
@@ -9866,7 +9921,16 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         void 0,
         enrichedReadCache
       );
-    case "content_block_delta":
+    }
+    case "content_block_delta": {
+      if (event.delta.type === "input_json_delta") {
+        return inputJsonDeltaToAcpNotifications(
+          event.index,
+          event.delta.partial_json,
+          sessionId,
+          toolUseStreamCache
+        );
+      }
       return toAcpNotifications(
         [event.delta],
         "assistant",
@@ -9882,16 +9946,36 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
         void 0,
         enrichedReadCache
       );
+    }
+    case "content_block_stop":
+      toolUseStreamCache.delete(event.index);
+      return [];
     case "message_start":
     case "message_delta":
     case "message_stop":
-    case "content_block_stop":
       return [];
     default:
       unreachable(event, logger);
       return [];
   }
 }
+function inputJsonDeltaToAcpNotifications(index, partialJson, sessionId, toolUseStreamCache) {
+  const entry = toolUseStreamCache.get(index);
+  if (!entry) return [];
+  entry.partialJson += partialJson;
+  const parsed = tryParsePartialJson(entry.partialJson);
+  if (!parsed || typeof parsed !== "object") return [];
+  return [
+    {
+      sessionId,
+      update: {
+        sessionUpdate: "tool_call_update",
+        toolCallId: entry.toolUseId,
+        rawInput: parsed
+      }
+    }
+  ];
+}
 async function handleSystemMessage(message, context) {
   const { session, sessionId, client, logger } = context;
   switch (message.subtype) {
@@ -10035,12 +10119,20 @@ function extractUsageFromResult(message) {
   };
 }
 async function handleStreamEvent(message, context) {
-  const { sessionId, client, toolUseCache, fileContentCache, logger } = context;
+  const {
+    sessionId,
+    client,
+    toolUseCache,
+    toolUseStreamCache,
+    fileContentCache,
+    logger
+  } = context;
   const parentToolCallId = message.parent_tool_use_id ?? void 0;
   for (const notification of streamEventToAcpNotifications(
     message,
     sessionId,
     toolUseCache,
+    toolUseStreamCache,
     fileContentCache,
     client,
     logger,
@@ -10953,6 +11045,31 @@ function getAvailableSlashCommands(commands) {
 }
 
 // src/adapters/claude/session/mcp-config.ts
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path8 from "path";
+function loadUserClaudeJsonMcpServers(cwd, logger, homeDir = os2.homedir()) {
+  const claudeJsonPath = path8.join(homeDir, ".claude.json");
+  let raw;
+  try {
+    raw = fs4.readFileSync(claudeJsonPath, "utf8");
+  } catch {
+    return {};
+  }
+  let cfg;
+  try {
+    cfg = JSON.parse(raw);
+  } catch (err2) {
+    logger?.warn("Failed to parse ~/.claude.json", {
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return {};
+  }
+  const topLevel = cfg.mcpServers && typeof cfg.mcpServers === "object" ? cfg.mcpServers : {};
+  const project = cfg.projects?.[cwd];
+  const projectScoped = project?.mcpServers && typeof project.mcpServers === "object" ? project.mcpServers : {};
+  return { ...topLevel, ...projectScoped };
+}
 function parseMcpServers(params) {
   const mcpServers = {};
   if (!Array.isArray(params.mcpServers)) {
@@ -11086,9 +11203,9 @@ function resolveModelPreference(preference, options) {
 
 // src/adapters/claude/session/options.ts
 import { spawn } from "child_process";
-import * as fs4 from "fs";
-import * as os2 from "os";
-import * as path8 from "path";
+import * as fs5 from "fs";
+import * as os3 from "os";
+import * as path9 from "path";
 
 // src/adapters/claude/session/instructions.ts
 var BRANCH_NAMING = `
@@ -11139,8 +11256,9 @@ function buildSystemPrompt(customPrompt) {
   }
   return defaultPrompt;
 }
-function buildMcpServers(userServers, acpServers) {
+function buildMcpServers(userServers, acpServers, projectScopedServers) {
   return {
+    ...projectScopedServers,
     ...userServers || {},
     ...acpServers
   };
@@ -11289,12 +11407,12 @@ function buildSpawnWrapper(sessionId, onProcessSpawned, onProcessExited, logger)
   };
 }
 function ensureLocalSettings(cwd) {
-  const claudeDir = path8.join(cwd, ".claude");
-  const localSettingsPath = path8.join(claudeDir, "settings.local.json");
+  const claudeDir = path9.join(cwd, ".claude");
+  const localSettingsPath = path9.join(claudeDir, "settings.local.json");
   try {
-    if (!fs4.existsSync(localSettingsPath)) {
-      fs4.mkdirSync(claudeDir, { recursive: true });
-      fs4.writeFileSync(localSettingsPath, "{}\n", { flag: "wx" });
+    if (!fs5.existsSync(localSettingsPath)) {
+      fs5.mkdirSync(claudeDir, { recursive: true });
+      fs5.writeFileSync(localSettingsPath, "{}\n", { flag: "wx" });
     }
   } catch {
   }
@@ -11324,7 +11442,8 @@ function buildSessionOptions(params) {
     },
     mcpServers: buildMcpServers(
       params.userProvidedOptions?.mcpServers,
-      params.mcpServers
+      params.mcpServers,
+      loadUserClaudeJsonMcpServers(params.cwd, params.logger)
     ),
     env: buildEnvironment(),
     hooks: buildHooks(
@@ -11369,18 +11488,18 @@ function buildSessionOptions(params) {
   return options;
 }
 function clearStatsigCache() {
-  const statsigPath = path8.join(
-    process.env.CLAUDE_CONFIG_DIR || path8.join(os2.homedir(), ".claude"),
+  const statsigPath = path9.join(
+    process.env.CLAUDE_CONFIG_DIR || path9.join(os3.homedir(), ".claude"),
     "statsig"
   );
-  fs4.rm(statsigPath, { recursive: true, force: true }, () => {
+  fs5.rm(statsigPath, { recursive: true, force: true }, () => {
   });
 }
 
 // src/adapters/claude/session/settings.ts
-import * as fs7 from "fs";
-import * as os3 from "os";
-import * as path11 from "path";
+import * as fs8 from "fs";
+import * as os4 from "os";
+import * as path12 from "path";
 import { minimatch } from "minimatch";
 
 // src/utils/async-mutex.ts
@@ -11413,8 +11532,8 @@ var AsyncMutex = class {
 };
 
 // ../git/dist/queries.js
-import * as fs6 from "fs/promises";
-import * as path10 from "path";
+import * as fs7 from "fs/promises";
+import * as path11 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -11453,8 +11572,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path15) {
-  return path15 instanceof String && cache.has(path15);
+function isPathSpec(path16) {
+  return path16 instanceof String && cache.has(path16);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -11543,8 +11662,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path15) {
-  return (0, import_file_exists.exists)(path15, import_file_exists.FOLDER);
+function folderExists(path16) {
+  return (0, import_file_exists.exists)(path16, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -11948,8 +12067,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path15) {
-      return /^\.(git)?$/.test(path15.trim());
+    parser(path16) {
+      return /^\.(git)?$/.test(path16.trim());
     }
   };
 }
@@ -12383,11 +12502,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path15, line, preview] = input.split(NULL);
-    paths.add(path15);
-    (results[path15] = results[path15] || []).push({
+    const [path16, line, preview] = input.split(NULL);
+    paths.add(path16);
+    (results[path16] = results[path16] || []).push({
       line: asNumber(line),
-      path: path15,
+      path: path16,
       preview
     });
   });
@@ -13152,14 +13271,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path15, text2) {
+function parseInit(bare, path16, text2) {
   const response = String(text2).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path15, false, result[1]);
+    return new InitSummary(bare, path16, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path15, true, result[1]);
+    return new InitSummary(bare, path16, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -13170,7 +13289,7 @@ function parseInit(bare, path15, text2) {
       break;
     }
   }
-  return new InitSummary(bare, path15, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path16, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -13179,9 +13298,9 @@ var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path15, existing, gitDir) {
+      constructor(bare, path16, existing, gitDir) {
         this.bare = bare;
-        this.path = path15;
+        this.path = path16;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -13193,7 +13312,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path15, customArgs) {
+function initTask(bare = false, path16, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -13202,7 +13321,7 @@ function initTask(bare = false, path15, customArgs) {
     commands,
     format: "utf-8",
     parser(text2) {
-      return parseInit(commands.includes("--bare"), path15, text2);
+      return parseInit(commands.includes("--bare"), path16, text2);
     }
   };
 }
@@ -14018,12 +14137,12 @@ var init_FileStatusSummary = __esm({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path15, index, working_dir) {
-        this.path = path15;
+      constructor(path16, index, working_dir) {
+        this.path = path16;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path15) || [null, path15, path15];
+          const detail = fromPathRegex.exec(path16) || [null, path16, path16];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -14054,14 +14173,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path15) {
+  function data(index, workingDir, path16) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path15);
+      handler(result, path16);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path15, index, workingDir));
+      result.files.push(new FileStatusSummary(path16, index, workingDir));
     }
   }
 }
@@ -14374,9 +14493,9 @@ var init_simple_git_api = __esm({
           next
         );
       }
-      hashObject(path15, write) {
+      hashObject(path16, write) {
         return this._runTask(
-          hashObjectTask(path15, write === true),
+          hashObjectTask(path16, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -14729,8 +14848,8 @@ var init_branch = __esm({
   }
 });
 function toPath(input) {
-  const path15 = input.trim().replace(/^["']|["']$/g, "");
-  return path15 && normalize(path15);
+  const path16 = input.trim().replace(/^["']|["']$/g, "");
+  return path16 && normalize(path16);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm({
@@ -15044,8 +15163,8 @@ __export(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path15) {
-  return subModuleTask(["add", repo, path15]);
+function addSubModuleTask(repo, path16) {
+  return subModuleTask(["add", repo, path16]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -15375,8 +15494,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path15, then) {
-      return this._runTask(addSubModuleTask2(repo, path15), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path16, then) {
+      return this._runTask(addSubModuleTask2(repo, path16), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(
@@ -15977,22 +16096,22 @@ function createGitClient(baseDir, options) {
 
 // ../git/dist/lock-detector.js
 import { execFile } from "child_process";
-import fs5 from "fs/promises";
-import path9 from "path";
+import fs6 from "fs/promises";
+import path10 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 path9.resolve(repoPath, stdout.trim());
+    return path10.resolve(repoPath, stdout.trim());
   } catch {
-    return path9.join(repoPath, ".git", "index.lock");
+    return path10.join(repoPath, ".git", "index.lock");
   }
 }
 async function getLockInfo(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
   try {
-    const stat2 = await fs5.stat(lockPath);
+    const stat2 = await fs6.stat(lockPath);
     return {
       path: lockPath,
       ageMs: Date.now() - stat2.mtimeMs
@@ -16003,7 +16122,7 @@ async function getLockInfo(repoPath) {
 }
 async function removeLock(repoPath) {
   const lockPath = await getIndexLockPath(repoPath);
-  await fs5.rm(lockPath, { force: true });
+  await fs6.rm(lockPath, { force: true });
 }
 async function isLocked(repoPath) {
   return await getLockInfo(repoPath) !== null;
@@ -16252,13 +16371,13 @@ function parseRule(rule) {
 function normalizePath(filePath, cwd) {
   let resolved = filePath;
   if (resolved.startsWith("~/")) {
-    resolved = path11.join(os3.homedir(), resolved.slice(2));
+    resolved = path12.join(os4.homedir(), resolved.slice(2));
   } else if (resolved.startsWith("./")) {
-    resolved = path11.join(cwd, resolved.slice(2));
-  } else if (!path11.isAbsolute(resolved)) {
-    resolved = path11.join(cwd, resolved);
+    resolved = path12.join(cwd, resolved.slice(2));
+  } else if (!path12.isAbsolute(resolved)) {
+    resolved = path12.join(cwd, resolved);
   }
-  return path11.normalize(resolved).replace(/\\/g, "/");
+  return path12.normalize(resolved).replace(/\\/g, "/");
 }
 function matchesGlob(pattern, filePath, cwd) {
   const normalizedPattern = normalizePath(pattern, cwd);
@@ -16305,11 +16424,11 @@ function formatRule(rule) {
 }
 async function writeFileAtomic(filePath, data) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs7.promises.writeFile(tmpPath, data);
+  await fs8.promises.writeFile(tmpPath, data);
   try {
-    await fs7.promises.rename(tmpPath, filePath);
+    await fs8.promises.rename(tmpPath, filePath);
   } catch (error) {
-    await fs7.promises.rm(tmpPath, { force: true });
+    await fs8.promises.rm(tmpPath, { force: true });
     throw error;
   }
 }
@@ -16318,7 +16437,7 @@ async function loadSettingsFile(filePath) {
     return {};
   }
   try {
-    const content = await fs7.promises.readFile(filePath, "utf-8");
+    const content = await fs8.promises.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -16333,7 +16452,7 @@ async function loadSettingsFile(filePath) {
 }
 async function readSettingsFileForUpdate(filePath) {
   try {
-    const content = await fs7.promises.readFile(filePath, "utf-8");
+    const content = await fs8.promises.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -16379,11 +16498,11 @@ var SettingsManager = class {
     return this.initPromise;
   }
   getUserSettingsPath() {
-    const configDir = process.env.CLAUDE_CONFIG_DIR || path11.join(os3.homedir(), ".claude");
-    return path11.join(configDir, "settings.json");
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path12.join(os4.homedir(), ".claude");
+    return path12.join(configDir, "settings.json");
   }
   getProjectSettingsPath() {
-    return path11.join(this.cwd, ".claude", "settings.json");
+    return path12.join(this.cwd, ".claude", "settings.json");
   }
   /**
    * Local settings are anchored to the primary worktree so every worktree of
@@ -16391,7 +16510,7 @@ var SettingsManager = class {
    * avoids re-prompting for the same permission in every worktree.
    */
   getLocalSettingsPath() {
-    return path11.join(this.repoRoot, ".claude", "settings.local.json");
+    return path12.join(this.repoRoot, ".claude", "settings.local.json");
   }
   async loadAllSettings() {
     this.repoRoot = await resolveMainRepoPath(this.cwd);
@@ -16518,7 +16637,7 @@ var SettingsManager = class {
       }
       permissions.allow = Array.from(current2);
       const next = { ...existing, permissions };
-      await fs7.promises.mkdir(path11.dirname(filePath), { recursive: true });
+      await fs8.promises.mkdir(path12.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
@@ -16551,7 +16670,7 @@ var SettingsManager = class {
         ...existing,
         posthogApprovedExecTools: Array.from(current2)
       };
-      await fs7.promises.mkdir(path11.dirname(filePath), { recursive: true });
+      await fs8.promises.mkdir(path12.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
@@ -16594,6 +16713,7 @@ function shouldEmitRawMessage(config, message) {
 var ClaudeAcpAgent = class extends BaseAcpAgent {
   adapterName = "claude";
   toolUseCache;
+  toolUseStreamCache;
   backgroundTerminals = {};
   clientCapabilities;
   options;
@@ -16603,6 +16723,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     super(client);
     this.options = options;
     this.toolUseCache = {};
+    this.toolUseStreamCache = /* @__PURE__ */ new Map();
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
     this.enrichment = createEnrichment(options?.posthogApiConfig, this.logger);
   }
@@ -16655,7 +16776,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     };
   }
   async newSession(params) {
-    if (fs8.existsSync(path12.resolve(os4.homedir(), ".claude.json.backup")) && !fs8.existsSync(path12.resolve(os4.homedir(), ".claude.json"))) {
+    if (fs9.existsSync(path13.resolve(os5.homedir(), ".claude.json.backup")) && !fs9.existsSync(path13.resolve(os5.homedir(), ".claude.json"))) {
       throw RequestError2.authRequired();
     }
     const response = await this.createSession(params, {
@@ -16797,6 +16918,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       sessionId: params.sessionId,
       client: this.client,
       toolUseCache: this.toolUseCache,
+      toolUseStreamCache: this.toolUseStreamCache,
       fileContentCache: this.fileContentCache,
       enrichedReadCache: this.enrichedReadCache,
       logger: this.logger,
@@ -17049,6 +17171,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       }
       throw error;
     } finally {
+      this.toolUseStreamCache.clear();
       if (!handedOff) {
         this.session.promptRunning = false;
         for (const [key, pending] of this.session.pendingMessages) {
@@ -17623,6 +17746,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         sessionId,
         client: this.client,
         toolUseCache: this.toolUseCache,
+        toolUseStreamCache: this.toolUseStreamCache,
         fileContentCache: this.fileContentCache,
         enrichedReadCache: this.enrichedReadCache,
         logger: this.logger,
@@ -17895,9 +18019,9 @@ function resetUsage(state) {
 }
 
 // src/adapters/codex/settings.ts
-import * as fs9 from "fs";
-import * as os5 from "os";
-import * as path13 from "path";
+import * as fs10 from "fs";
+import * as os6 from "os";
+import * as path14 from "path";
 var CodexSettingsManager = class {
   cwd;
   settings = { mcpServerNames: [] };
@@ -17908,12 +18032,12 @@ var CodexSettingsManager = class {
   async initialize() {
   }
   getConfigPath() {
-    return path13.join(os5.homedir(), ".codex", "config.toml");
+    return path14.join(os6.homedir(), ".codex", "config.toml");
   }
   loadSettings() {
     const configPath = this.getConfigPath();
     try {
-      const content = fs9.readFileSync(configPath, "utf-8");
+      const content = fs10.readFileSync(configPath, "utf-8");
       this.settings = parseCodexToml(content, this.cwd);
     } catch {
       this.settings = { mcpServerNames: [] };
@@ -18891,9 +19015,9 @@ var PostHogAPIClient = class {
 };
 
 // src/session-log-writer.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import fsp from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 var SessionLogWriter = class _SessionLogWriter {
   static FLUSH_DEBOUNCE_MS = 500;
   static FLUSH_MAX_INTERVAL_MS = 5e3;
@@ -18929,13 +19053,13 @@ var SessionLogWriter = class _SessionLogWriter {
     this.sessions.set(sessionId, { context, currentTurnMessages: [] });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
     if (this.localCachePath) {
-      const sessionDir = path14.join(
+      const sessionDir = path15.join(
         this.localCachePath,
         "sessions",
         context.runId
       );
       try {
-        fs10.mkdirSync(sessionDir, { recursive: true });
+        fs11.mkdirSync(sessionDir, { recursive: true });
       } catch (error) {
         this.logger.warn("Failed to create local cache directory", {
           sessionDir,
@@ -19187,14 +19311,14 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!this.localCachePath) return;
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    const logPath = path14.join(
+    const logPath = path15.join(
       this.localCachePath,
       "sessions",
       session.context.runId,
       "logs.ndjson"
     );
     try {
-      fs10.appendFileSync(logPath, `${JSON.stringify(entry)}
+      fs11.appendFileSync(logPath, `${JSON.stringify(entry)}
 `);
     } catch (error) {
       this.logger.warn("Failed to write to local cache", {
@@ -19206,13 +19330,13 @@ var SessionLogWriter = class _SessionLogWriter {
     }
   }
   static async cleanupOldSessions(localCachePath) {
-    const sessionsDir = path14.join(localCachePath, "sessions");
+    const sessionsDir = path15.join(localCachePath, "sessions");
     let deleted = 0;
     try {
       const entries = await fsp.readdir(sessionsDir);
       const now = Date.now();
       for (const entry of entries) {
-        const entryPath = path14.join(sessionsDir, entry);
+        const entryPath = path15.join(sessionsDir, entry);
         try {
           const stats = await fsp.stat(entryPath);
           if (stats.isDirectory() && now - stats.birthtimeMs > _SessionLogWriter.SESSIONS_MAX_AGE_MS) {