@posthog/agent 2.3.727 → 2.3.736

package/dist/agent.js

@@ -4674,7 +4674,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.727",
+  version: "2.3.736",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -4794,9 +4794,9 @@ var package_default = {
     vitest: "^2.1.8"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "0.19.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.112",
-    "@anthropic-ai/sdk": "0.89.0",
+    "@agentclientprotocol/sdk": "0.22.1",
+    "@anthropic-ai/claude-agent-sdk": "0.3.154",
+    "@anthropic-ai/sdk": "0.100.0",
     "@hono/node-server": "^1.19.9",
     "@opentelemetry/api-logs": "^0.208.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.208.0",
@@ -10183,6 +10183,30 @@ var registerHookCallback = (toolUseID, {
     onPostToolUseHook
   };
 };
+var createTaskHook = (taskState, onChange) => async (input) => {
+  const taskId = "task_id" in input && typeof input.task_id === "string" ? input.task_id : void 0;
+  if (!taskId) return { continue: true };
+  let mutated = false;
+  if (input.hook_event_name === "TaskCreated") {
+    if (!input.task_subject) return { continue: true };
+    if (taskState.has(taskId)) return { continue: true };
+    taskState.set(taskId, {
+      subject: input.task_subject,
+      status: "pending",
+      description: input.task_description
+    });
+    mutated = true;
+  } else if (input.hook_event_name === "TaskCompleted") {
+    const existing = taskState.get(taskId);
+    if (!existing || existing.status === "completed") {
+      return { continue: true };
+    }
+    taskState.set(taskId, { ...existing, status: "completed" });
+    mutated = true;
+  }
+  if (mutated && onChange) await onChange();
+  return { continue: true };
+};
 var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
   if (input.hook_event_name === "PostToolUse") {
     const toolName = input.tool_name;
@@ -10197,10 +10221,8 @@ var createPostToolUseHook = ({ onModeChange }) => async (input, toolUseID) => {
           input.tool_input,
           input.tool_response
         );
-        delete toolUseCallbacks[toolUseID];
-      } else {
-        delete toolUseCallbacks[toolUseID];
       }
+      delete toolUseCallbacks[toolUseID];
     }
   }
   return { continue: true };
@@ -10347,6 +10369,104 @@ var createPreToolUseHook = (settingsManager, logger) => async (input, _toolUseID
   }
 };
 
+// src/adapters/claude/conversion/task-state.ts
+function parseTaskCreateOutput(content) {
+  const tryParse = (text2) => {
+    try {
+      const parsed = JSON.parse(text2);
+      if (parsed && typeof parsed === "object" && parsed.task && typeof parsed.task.id === "string") {
+        return parsed;
+      }
+    } catch {
+    }
+    return void 0;
+  };
+  if (typeof content === "string") {
+    return tryParse(content);
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block && typeof block === "object" && "type" in block && block.type === "text") {
+        const text2 = block.text;
+        if (typeof text2 === "string") {
+          const parsed = tryParse(text2);
+          if (parsed) return parsed;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function applyTaskCreate(state, input, output) {
+  const taskId = output?.task?.id;
+  if (!taskId || !input) return;
+  state.set(taskId, {
+    subject: input.subject,
+    status: "pending",
+    activeForm: input.activeForm,
+    description: input.description
+  });
+}
+function applyTaskUpdate(state, input) {
+  if (!input?.taskId) return;
+  if (input.status === "deleted") {
+    state.delete(input.taskId);
+    return;
+  }
+  const existing = state.get(input.taskId);
+  const subject = input.subject ?? existing?.subject;
+  if (!subject) return;
+  state.set(input.taskId, {
+    subject,
+    status: input.status ?? existing?.status ?? "pending",
+    activeForm: input.activeForm ?? existing?.activeForm,
+    description: input.description ?? existing?.description
+  });
+}
+function taskStateToPlanEntries(state) {
+  return Array.from(state.values()).map((task) => ({
+    content: task.subject,
+    status: task.status,
+    priority: "medium"
+  }));
+}
+function isToolUseBlock(block) {
+  return !!block && typeof block === "object" && block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string";
+}
+function isToolResultBlock(block) {
+  return !!block && typeof block === "object" && block.type === "tool_result" && typeof block.tool_use_id === "string";
+}
+function rehydrateTaskState(messages, state) {
+  const pendingInputs = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const content = msg.message?.content;
+    if (!Array.isArray(content)) continue;
+    if (msg.type === "assistant") {
+      for (const block of content) {
+        if (isToolUseBlock(block) && (block.name === "TaskCreate" || block.name === "TaskUpdate")) {
+          pendingInputs.set(block.id, { name: block.name, input: block.input });
+        }
+      }
+    } else if (msg.type === "user") {
+      for (const block of content) {
+        if (!isToolResultBlock(block) || block.is_error) continue;
+        const cached = pendingInputs.get(block.tool_use_id);
+        if (!cached) continue;
+        if (cached.name === "TaskCreate") {
+          applyTaskCreate(
+            state,
+            cached.input,
+            parseTaskCreateOutput(block.content)
+          );
+        } else if (cached.name === "TaskUpdate") {
+          applyTaskUpdate(state, cached.input);
+        }
+        pendingInputs.delete(block.tool_use_id);
+      }
+    }
+  }
+}
+
 // src/adapters/claude/conversion/tool-use-to-acp.ts
 import fs4 from "fs";
 import path7 from "path";
@@ -10698,9 +10818,31 @@ function toolInfoFromToolUse(toolUse, options) {
         content: []
       };
     }
-    case "TodoWrite":
+    case "TaskCreate": {
+      const subject = typeof input?.subject === "string" ? input.subject : void 0;
+      return {
+        title: subject ? `Create task: ${subject}` : "Create task",
+        kind: "think",
+        content: []
+      };
+    }
+    case "TaskUpdate": {
+      const subject = typeof input?.subject === "string" ? input.subject : void 0;
       return {
-        title: Array.isArray(input?.todos) ? `Update TODOs: ${input.todos.map((todo) => todo.content).join(", ")}` : "Update TODOs",
+        title: subject ? `Update task: ${subject}` : "Update task",
+        kind: "think",
+        content: []
+      };
+    }
+    case "TaskList":
+      return {
+        title: "List tasks",
+        kind: "think",
+        content: []
+      };
+    case "TaskGet":
+      return {
+        title: "Get task",
         kind: "think",
         content: []
       };
@@ -10984,13 +11126,6 @@ ${content}
   }
   return {};
 }
-function planEntries(input) {
-  return input.todos.map((input2) => ({
-    content: input2.content,
-    status: input2.status,
-    priority: "medium"
-  }));
-}
 function resolveFileContent(filePath, oldText, cachedFileContent) {
   if (cachedFileContent && filePath in cachedFileContent) {
     const cached = cachedFileContent[filePath];
@@ -11076,14 +11211,7 @@ function handleThinkingChunk(chunk, parentToolCallId) {
 function handleToolUseChunk(chunk, ctx) {
   const alreadyCached = chunk.id in ctx.toolUseCache;
   ctx.toolUseCache[chunk.id] = chunk;
-  if (chunk.name === "TodoWrite") {
-    const input = chunk.input;
-    if (Array.isArray(input.todos)) {
-      return {
-        sessionUpdate: "plan",
-        entries: planEntries(chunk.input)
-      };
-    }
+  if (chunk.name === "TaskCreate" || chunk.name === "TaskUpdate" || chunk.name === "TaskList" || chunk.name === "TaskGet") {
     return null;
   }
   if (!alreadyCached && ctx.registerHooks !== false) {
@@ -11091,7 +11219,7 @@ function handleToolUseChunk(chunk, ctx) {
       onPostToolUseHook: async (toolUseId, _toolInput, toolResponse) => {
         const toolUse = ctx.toolUseCache[toolUseId];
         if (toolUse) {
-          const editUpdate = toolUse.name === "Edit" ? toolUpdateFromEditToolResponse(toolResponse) : null;
+          const editUpdate = toolUse.name === "Edit" || toolUse.name === "Write" ? toolUpdateFromEditToolResponse(toolResponse) : null;
           await ctx.client.sessionUpdate({
             sessionId: ctx.sessionId,
             update: {
@@ -11203,7 +11331,28 @@ function handleToolResultChunk(chunk, ctx) {
     );
     return [];
   }
-  if (toolUse.name === "TodoWrite") {
+  if (toolUse.name === "TaskCreate" || toolUse.name === "TaskUpdate" || toolUse.name === "TaskList" || toolUse.name === "TaskGet") {
+    if (chunk.is_error || !ctx.taskState) return [];
+    if (toolUse.name === "TaskCreate") {
+      applyTaskCreate(
+        ctx.taskState,
+        toolUse.input,
+        parseTaskCreateOutput(chunk.content)
+      );
+    } else if (toolUse.name === "TaskUpdate") {
+      applyTaskUpdate(
+        ctx.taskState,
+        toolUse.input
+      );
+    }
+    if (toolUse.name === "TaskCreate" || toolUse.name === "TaskUpdate") {
+      return [
+        {
+          sessionUpdate: "plan",
+          entries: taskStateToPlanEntries(ctx.taskState)
+        }
+      ];
+    }
     return [];
   }
   if (!chunk.is_error) {
@@ -11300,13 +11449,15 @@ function processContentChunk(chunk, role, ctx) {
     case "container_upload":
     case "compaction":
     case "compaction_delta":
+    case "advisor_tool_result":
+    case "mid_conv_system":
       return [];
     default:
       unreachable(chunk, ctx.logger);
       return [];
   }
 }
-function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, mcpToolUseResult, enrichedReadCache) {
+function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, mcpToolUseResult, enrichedReadCache, taskState) {
   if (typeof content === "string") {
     const update = {
       sessionUpdate: messageUpdateType(role),
@@ -11332,7 +11483,8 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
     registerHooks,
     supportsTerminalOutput,
     cwd,
-    mcpToolUseResult
+    mcpToolUseResult,
+    taskState
   };
   const output = [];
   for (const chunk of content) {
@@ -11342,7 +11494,7 @@ function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentC
   }
   return output;
 }
-function streamEventToAcpNotifications(message, sessionId, toolUseCache, toolUseStreamCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, enrichedReadCache) {
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, toolUseStreamCache, fileContentCache, client, logger, parentToolCallId, registerHooks, supportsTerminalOutput, cwd, enrichedReadCache, taskState) {
   const event = message.event;
   switch (event.type) {
     case "content_block_start": {
@@ -11366,7 +11518,8 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, toolUse
         supportsTerminalOutput,
         cwd,
         void 0,
-        enrichedReadCache
+        enrichedReadCache,
+        taskState
       );
     }
     case "content_block_delta": {
@@ -11391,12 +11544,18 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, toolUse
         supportsTerminalOutput,
         cwd,
         void 0,
-        enrichedReadCache
+        enrichedReadCache,
+        taskState
       );
     }
     case "content_block_stop":
       toolUseStreamCache.delete(event.index);
       return [];
+    // `ping` is a Messages-API keep-alive event that the SDK's
+    // `BetaRawMessageStreamEvent` union doesn't include even though the
+    // wire format emits it; the `as never` cast lets us no-op it here
+    // instead of falling through to `unreachable`.
+    case "ping":
     case "message_start":
     case "message_delta":
     case "message_stop":
@@ -11467,6 +11626,38 @@ async function handleSystemMessage(message, context) {
       });
       break;
     }
+    case "memory_recall": {
+      const isSynthesis = message.mode === "synthesize";
+      if (!isSynthesis && message.memories.length === 0) break;
+      const locations = isSynthesis ? [] : message.memories.map((m) => ({ path: m.path }));
+      const content = isSynthesis ? message.memories.filter(
+        (m) => typeof m.content === "string"
+      ).map((m) => ({
+        type: "content",
+        content: { type: "text", text: m.content }
+      })) : [];
+      const count = message.memories.length;
+      const title = isSynthesis ? "Recalled synthesized memory" : `Recalled ${count} ${count === 1 ? "memory" : "memories"}`;
+      await client.sessionUpdate({
+        sessionId: message.session_id,
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId: message.uuid,
+          title,
+          kind: "read",
+          status: "completed",
+          ...locations.length > 0 && { locations },
+          ...content.length > 0 && { content },
+          _meta: {
+            claudeCode: {
+              toolName: "memory_recall",
+              toolResponse: { mode: message.mode }
+            }
+          }
+        }
+      });
+      break;
+    }
     default:
       break;
   }
@@ -11576,7 +11767,8 @@ async function handleStreamEvent(message, context) {
     context.registerHooks,
     context.supportsTerminalOutput,
     context.session.cwd,
-    context.enrichedReadCache
+    context.enrichedReadCache,
+    context.session.taskState
   )) {
     await client.sessionUpdate(notification);
     context.session.notificationHistory.push(notification);
@@ -11588,6 +11780,17 @@ function hasLocalCommandStdout(content) {
 function hasLocalCommandStderr(content) {
   return typeof content === "string" && content.includes("<local-command-stderr>");
 }
+function isSdkLocalCommandMessage(content) {
+  return typeof content === "string" && content.includes("<command-name>") && (content.includes("<local-command-stdout>") || content.includes("<local-command-stderr>"));
+}
+var LOCAL_COMMAND_TAG_PATTERN = /<(command-name|command-message|command-args|local-command-stdout|local-command-stderr)>[\s\S]*?<\/\1>/g;
+function stripMarkerTags(text2) {
+  return text2.replace(LOCAL_COMMAND_TAG_PATTERN, "");
+}
+function stripLocalCommandMetadata(content) {
+  const stripped = stripMarkerTags(content);
+  return stripped.trim() === "" ? null : stripped;
+}
 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;
 }
@@ -11596,7 +11799,7 @@ function isPlainTextUserMessage(message) {
   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) || isLoginRequiredMessage(message);
+  return isSdkLocalCommandMessage(message.message.content) || isLoginRequiredMessage(message);
 }
 function logSpecialMessages(message, logger) {
   const content = message.message.content;
@@ -11617,11 +11820,39 @@ function filterMessageContent(content) {
 }
 async function handleUserAssistantMessage(message, context) {
   const { session, sessionId, client, toolUseCache, fileContentCache, logger } = context;
+  if (message.message.role === "system") {
+    return {};
+  }
   if (shouldSkipUserAssistantMessage(message)) {
     logSpecialMessages(message, logger);
     if (isLoginRequiredMessage(message)) {
       return { shouldStop: true, error: RequestError.authRequired() };
     }
+    const rawContent = message.message.content;
+    if (typeof rawContent === "string") {
+      const stripped = stripLocalCommandMetadata(rawContent);
+      if (stripped !== null) {
+        for (const notification of toAcpNotifications(
+          stripped,
+          message.message.role,
+          sessionId,
+          toolUseCache,
+          fileContentCache,
+          client,
+          logger,
+          void 0,
+          context.registerHooks,
+          context.supportsTerminalOutput,
+          session.cwd,
+          void 0,
+          context.enrichedReadCache,
+          session.taskState
+        )) {
+          await client.sessionUpdate(notification);
+          session.notificationHistory.push(notification);
+        }
+      }
+    }
     return {};
   }
   if (isPlainTextUserMessage(message)) {
@@ -11644,7 +11875,8 @@ async function handleUserAssistantMessage(message, context) {
     context.supportsTerminalOutput,
     session.cwd,
     mcpToolUseResult,
-    context.enrichedReadCache
+    context.enrichedReadCache,
+    session.taskState
   )) {
     await client.sessionUpdate(notification);
     session.notificationHistory.push(notification);
@@ -11840,8 +12072,10 @@ var WEB_TOOLS = /* @__PURE__ */ new Set(["WebSearch", "WebFetch"]);
 var AGENT_TOOLS = /* @__PURE__ */ new Set([
   "Task",
   "Agent",
-  "TodoWrite",
-  "Skill"
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskGet",
+  "TaskList"
 ]);
 var BASE_ALLOWED_TOOLS = [
   ...READ_TOOLS,
@@ -11925,8 +12159,8 @@ function buildPermissionOptions(toolName, toolInput, repoRoot, suggestions) {
   if (toolName === "Task") {
     return permissionOptions("Yes, allow all sub-tasks");
   }
-  if (toolName === "TodoWrite") {
-    return permissionOptions("Yes, allow all todo updates");
+  if (toolName === "TaskCreate" || toolName === "TaskUpdate" || toolName === "TaskGet" || toolName === "TaskList") {
+    return permissionOptions("Yes, allow all task updates");
   }
   return permissionOptions("Yes, always allow");
 }
@@ -12478,6 +12712,7 @@ async function canUseTool(context) {
 
 // src/adapters/claude/session/commands.ts
 var UNSUPPORTED_COMMANDS = [
+  "clear",
   "context",
   "cost",
   "keybindings-help",
@@ -12532,18 +12767,30 @@ function loadUserClaudeJsonMcpServers(cwd, logger, homeDir = os3.homedir()) {
   const projectScoped = project?.mcpServers && typeof project.mcpServers === "object" ? project.mcpServers : {};
   return { ...topLevel, ...projectScoped };
 }
-function parseMcpServers(params) {
+function parseMcpServers(params, logger) {
   const mcpServers = {};
   if (!Array.isArray(params.mcpServers)) {
     return mcpServers;
   }
   for (const server of params.mcpServers) {
     if ("type" in server) {
-      mcpServers[server.name] = {
-        type: server.type,
-        url: server.url,
-        headers: server.headers ? Object.fromEntries(server.headers.map((e) => [e.name, e.value])) : void 0
-      };
+      if (server.type === "http" || server.type === "sse") {
+        mcpServers[server.name] = {
+          type: server.type,
+          url: server.url,
+          headers: server.headers ? Object.fromEntries(
+            server.headers.map((e) => [
+              e.name,
+              e.value
+            ])
+          ) : void 0
+        };
+      } else {
+        logger?.warn("parseMcpServers: dropping unsupported MCP server type", {
+          name: server.name,
+          type: server.type
+        });
+      }
     } else {
       mcpServers[server.name] = {
         type: "stdio",
@@ -12556,12 +12803,43 @@ function parseMcpServers(params) {
   return mcpServers;
 }
 
+// src/adapters/claude/session/model-config.ts
+function applyAvailableModelsAllowlist(modelOptions, allowlist) {
+  const filtered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of allowlist) {
+    const trimmed2 = entry.trim();
+    if (!trimmed2 || seen.has(trimmed2)) continue;
+    const match = modelOptions.options.find((o) => o.value === trimmed2);
+    if (match) {
+      filtered.push(match);
+      seen.add(trimmed2);
+    }
+  }
+  if (filtered.length === 0) return modelOptions;
+  const currentModelId = filtered.some(
+    (o) => o.value === modelOptions.currentModelId
+  ) ? modelOptions.currentModelId : filtered[0].value;
+  return { currentModelId, options: filtered };
+}
+function resolveInitialModelId(modelOptions, preferredModelIds) {
+  const allowedModelIds = new Set(modelOptions.options.map((opt) => opt.value));
+  for (const candidate of preferredModelIds) {
+    const trimmed2 = candidate?.trim();
+    if (trimmed2 && allowedModelIds.has(trimmed2)) {
+      return trimmed2;
+    }
+  }
+  return modelOptions.currentModelId;
+}
+
 // src/adapters/claude/session/models.ts
 var DEFAULT_MODEL = "opus";
 var GATEWAY_TO_SDK_MODEL = {
   "claude-opus-4-5": "opus",
   "claude-opus-4-6": "opus",
   "claude-opus-4-7": "opus",
+  "claude-opus-4-8": "opus",
   "claude-sonnet-4-5": "sonnet",
   "claude-sonnet-4-6": "sonnet",
   "claude-haiku-4-5": "haiku"
@@ -12572,6 +12850,7 @@ function toSdkModelId(modelId) {
 var MODELS_WITH_1M_CONTEXT = /* @__PURE__ */ new Set([
   "claude-opus-4-6",
   "claude-opus-4-7",
+  "claude-opus-4-8",
   "claude-sonnet-4-6"
 ]);
 function supports1MContext(modelId) {
@@ -12581,11 +12860,13 @@ var MODELS_WITH_EFFORT = /* @__PURE__ */ new Set([
   "claude-opus-4-5",
   "claude-opus-4-6",
   "claude-opus-4-7",
+  "claude-opus-4-8",
   "claude-sonnet-4-6"
 ]);
 var MODELS_WITH_XHIGH_EFFORT = /* @__PURE__ */ new Set([
   "claude-opus-4-6",
-  "claude-opus-4-7"
+  "claude-opus-4-7",
+  "claude-opus-4-8"
 ]);
 function supportsEffort(modelId) {
   return MODELS_WITH_EFFORT.has(modelId);
@@ -12625,6 +12906,19 @@ function tokenizeModelPreference(model) {
   }).filter((token) => token && token !== "claude").filter((token) => /[a-z]/.test(token) || token.endsWith("m"));
   return { tokens, contextHint };
 }
+var MODEL_FAMILY_VERSION_PATTERN = /\b(\d+)[-.](\d+)\b/;
+function extractModelFamilyVersion(s) {
+  if (!s) return null;
+  const match = s.match(MODEL_FAMILY_VERSION_PATTERN);
+  return match ? `${match[1]}.${match[2]}` : null;
+}
+function modelVersionsCompatible(preference, candidate) {
+  const preferred = extractModelFamilyVersion(preference);
+  if (!preferred) return true;
+  const candidateVersion = extractModelFamilyVersion(candidate.value) ?? extractModelFamilyVersion(candidate.name) ?? extractModelFamilyVersion(candidate.description);
+  if (!candidateVersion) return true;
+  return preferred === candidateVersion;
+}
 function scoreModelMatch(model, tokens, contextHint) {
   const haystack = `${model.value} ${model.name ?? ""}`.toLowerCase();
   let score = 0;
@@ -12644,6 +12938,7 @@ function resolveModelPreference(preference, options) {
   );
   if (directMatch) return directMatch.value;
   const includesMatch = options.find((o) => {
+    if (!modelVersionsCompatible(trimmed2, o)) return false;
     const value = o.value.toLowerCase();
     const display = (o.name ?? "").toLowerCase();
     return value.includes(lower) || display.includes(lower) || lower.includes(value);
@@ -12654,6 +12949,7 @@ function resolveModelPreference(preference, options) {
   let bestMatch = null;
   let bestScore = 0;
   for (const model of options) {
+    if (!modelVersionsCompatible(trimmed2, model)) continue;
     const score = scoreModelMatch(model, tokens, contextHint);
     if (0 < score && (!bestMatch || bestScore < score)) {
       bestMatch = model;
@@ -12730,6 +13026,7 @@ function buildEnvironment() {
   const existingCustomHeaders = process.env.ANTHROPIC_CUSTOM_HEADERS;
   const customHeaders = existingCustomHeaders ? `${existingCustomHeaders}
 ${bedrockFallbackHeader}` : bedrockFallbackHeader;
+  const mcpNonblocking = process.env.MCP_CONNECTION_NONBLOCKING;
   return {
     ...process.env,
     ELECTRON_RUN_AS_NODE: "1",
@@ -12738,11 +13035,14 @@ ${bedrockFallbackHeader}` : bedrockFallbackHeader;
     ENABLE_TOOL_SEARCH: "auto:0",
     // Enable idle state as end-of-turn signal (required for SDK 0.2.114+)
     CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: "1",
+    ...mcpNonblocking !== void 0 && {
+      MCP_CONNECTION_NONBLOCKING: mcpNonblocking
+    },
     // Route to AWS Bedrock as a fallback when Anthropic returns 5xx
     ANTHROPIC_CUSTOM_HEADERS: customHeaders
   };
 }
-function buildHooks(userHooks, onModeChange, settingsManager, logger, enrichmentDeps, enrichedReadCache, registeredAgents, cloudMode) {
+function buildHooks(userHooks, onModeChange, settingsManager, logger, enrichmentDeps, enrichedReadCache, registeredAgents, cloudMode, taskState, onTaskStateChange) {
   const postToolUseHooks = [createPostToolUseHook({ onModeChange })];
   if (enrichmentDeps && enrichedReadCache) {
     postToolUseHooks.push(
@@ -12756,13 +13056,16 @@ function buildHooks(userHooks, onModeChange, settingsManager, logger, enrichment
   if (cloudMode) {
     preToolUseHooks.push(createSignedCommitGuardHook(logger));
   }
+  const taskHook = createTaskHook(taskState, onTaskStateChange);
   return {
     ...userHooks,
     PostToolUse: [
       ...userHooks?.PostToolUse || [],
       { hooks: postToolUseHooks }
     ],
-    PreToolUse: [...userHooks?.PreToolUse || [], { hooks: preToolUseHooks }]
+    PreToolUse: [...userHooks?.PreToolUse || [], { hooks: preToolUseHooks }],
+    TaskCreated: [...userHooks?.TaskCreated || [], { hooks: [taskHook] }],
+    TaskCompleted: [...userHooks?.TaskCompleted || [], { hooks: [taskHook] }]
   };
 }
 var PH_EXPLORE_AGENT = {
@@ -12793,7 +13096,10 @@ Rules:
     "WebFetch",
     "WebSearch",
     "NotebookRead",
-    "TodoWrite"
+    "TaskCreate",
+    "TaskUpdate",
+    "TaskGet",
+    "TaskList"
   ]
 };
 function buildAgents(userAgents) {
@@ -12921,7 +13227,9 @@ function buildSessionOptions(params) {
       params.enrichmentDeps,
       params.enrichedReadCache,
       registeredAgentNames,
-      params.cloudMode ?? false
+      params.cloudMode ?? false,
+      params.taskState,
+      params.onTaskStateChange
     ),
     outputFormat: params.outputFormat,
     abortController: getAbortController(
@@ -17957,6 +18265,15 @@ function getManagedSettingsPath() {
       return "/etc/claude-code/managed-settings.json";
   }
 }
+function mergeAvailableModels(existing, incoming, layer) {
+  if (incoming === void 0) {
+    return existing;
+  }
+  if (layer === "enterprise") {
+    return Array.from(new Set(incoming));
+  }
+  return Array.from(/* @__PURE__ */ new Set([...existing ?? [], ...incoming]));
+}
 var SettingsManager = class {
   cwd;
   repoRoot;
@@ -18012,10 +18329,10 @@ var SettingsManager = class {
   }
   mergeAllSettings() {
     const allSettings = [
-      this.userSettings,
-      this.projectSettings,
-      this.localSettings,
-      this.enterpriseSettings
+      { layer: "user", settings: this.userSettings },
+      { layer: "project", settings: this.projectSettings },
+      { layer: "local", settings: this.localSettings },
+      { layer: "enterprise", settings: this.enterpriseSettings }
     ];
     const permissions = {
       allow: [],
@@ -18024,7 +18341,7 @@ var SettingsManager = class {
     };
     const merged = { permissions };
     const posthogApprovedExecTools = /* @__PURE__ */ new Set();
-    for (const settings of allSettings) {
+    for (const { layer, settings } of allSettings) {
       if (settings.permissions) {
         if (settings.permissions.allow) {
           permissions.allow?.push(...settings.permissions.allow);
@@ -18051,6 +18368,11 @@ var SettingsManager = class {
       if (settings.model) {
         merged.model = settings.model;
       }
+      merged.availableModels = mergeAvailableModels(
+        merged.availableModels,
+        settings.availableModels,
+        layer
+      );
       if (settings.posthogApprovedExecTools) {
         for (const tool2 of settings.posthogApprovedExecTools) {
           posthogApprovedExecTools.add(tool2);
@@ -18193,6 +18515,14 @@ function readClaudeMdQuietly(cwd, logger) {
     return void 0;
   }
 }
+function collectKnownSlashCommands(commands) {
+  const names = /* @__PURE__ */ new Set();
+  if (!commands) return names;
+  for (const cmd of commands) {
+    if (cmd.name) names.add(cmd.name);
+  }
+  return names;
+}
 function sanitizeTitle(text2) {
   const sanitized = text2.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
   if (sanitized.length <= MAX_TITLE_LENGTH) {
@@ -18251,6 +18581,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         },
         loadSession: true,
         sessionCapabilities: {
+          additionalDirectories: {},
           list: {},
           fork: {},
           resume: {}
@@ -18276,10 +18607,18 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (fs10.existsSync(path14.resolve(os6.homedir(), ".claude.json.backup")) && !fs10.existsSync(path14.resolve(os6.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 response = await this.createSession(
+      {
+        cwd: params.cwd,
+        mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
+        _meta: params._meta
+      },
+      {
+        // Revisit these meta values once we support resume
+        resume: params._meta?.claudeCode?.options?.resume
+      }
+    );
     return response;
   }
   async unstable_forkSession(params) {
@@ -18287,24 +18626,27 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta
       },
       { resume: params.sessionId, forkSession: true }
     );
   }
-  async unstable_resumeSession(params) {
+  async resumeSession(params) {
     const existing = this.getExistingSessionState(params.sessionId);
     if (existing) return existing;
     const response = await this.createSession(
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta
       },
       {
         resume: params.sessionId
       }
     );
+    await this.rehydrateTaskStateFromJsonl(params.sessionId);
     return response;
   }
   async loadSession(params) {
@@ -18314,6 +18656,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       {
         cwd: params.cwd,
         mcpServers: params.mcpServers ?? [],
+        additionalDirectories: params.additionalDirectories,
         _meta: params._meta
       },
       { resume: params.sessionId, skipBackgroundFetches: true }
@@ -18392,6 +18735,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     await this.broadcastUserMessage(params);
     this.session.promptRunning = true;
     let handedOff = false;
+    let errored = false;
     let lastAssistantTotalUsage = null;
     let lastStreamUsage = {
       input_tokens: 0,
@@ -18399,6 +18743,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       cache_read_input_tokens: 0,
       cache_creation_input_tokens: 0
     };
+    let compactionInProgress = false;
     if (this.session.lastContextWindowSize == null) {
       this.session.lastContextWindowSize = this.getContextWindowForModel(
         this.session.modelId ?? ""
@@ -18456,9 +18801,45 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             if (message.subtype === "local_command_output") {
               promptReplayed = true;
             }
+            if (message.subtype === "status") {
+              if (message.status === "compacting") {
+                compactionInProgress = true;
+              } else if (message.compact_result === "success" && compactionInProgress) {
+                compactionInProgress = false;
+                await this.client.sessionUpdate({
+                  sessionId: params.sessionId,
+                  update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                      type: "text",
+                      text: "\n\nCompacting completed."
+                    }
+                  }
+                });
+                break;
+              } else if (message.compact_result === "failed" && compactionInProgress) {
+                compactionInProgress = false;
+                const reason = message.compact_error ? `: ${message.compact_error}` : ".";
+                await this.client.sessionUpdate({
+                  sessionId: params.sessionId,
+                  update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                      type: "text",
+                      text: `
+
+Compacting failed${reason}`
+                    }
+                  }
+                });
+                break;
+              }
+            }
             if (message.subtype === "session_state_changed" && message.state === "idle") {
               if (!promptReplayed) {
-                if (commandMatch) {
+                const cmdName = commandMatch?.[1].slice(1);
+                const known = cmdName !== void 0 && this.session.knownSlashCommands?.has(cmdName) === true;
+                if (commandMatch && !known) {
                   const cmd = commandMatch[1];
                   this.logger.warn(
                     "Slash command produced no output; treating as unsupported",
@@ -18477,7 +18858,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                   return { stopReason: "end_turn" };
                 }
                 this.logger.debug("Skipping idle state before prompt replay", {
-                  sessionId: params.sessionId
+                  sessionId: params.sessionId,
+                  command: commandMatch?.[1],
+                  known
                 });
                 break;
               }
@@ -18491,7 +18874,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                   size: lastContextWindowSize
                 }
               });
-              return { stopReason: "end_turn" };
+              return {
+                stopReason: this.session.cancelled ? "cancelled" : "end_turn"
+              };
             }
             await handleSystemMessage(message, context);
             break;
@@ -18674,6 +19059,28 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       }
       throw new Error("Session did not end in result");
     } catch (error) {
+      errored = true;
+      try {
+        await this.session.query.interrupt();
+        const MAX_DRAIN = 100;
+        for (let i2 = 0; i2 < MAX_DRAIN; i2++) {
+          const { value: m, done } = await this.session.query.next();
+          if (done || !m) break;
+          if (m.type === "system" && m.subtype === "session_state_changed" && m.state === "idle") {
+            break;
+          }
+          if (i2 === MAX_DRAIN - 1) {
+            this.logger.error(
+              `Session ${params.sessionId}: drained ${MAX_DRAIN} messages after error without observing idle`
+            );
+          }
+        }
+      } catch (drainErr) {
+        this.logger.error(
+          `Session ${params.sessionId}: failed to drain query after prompt error`,
+          { error: drainErr }
+        );
+      }
       if (error instanceof RequestError2 || !(error instanceof Error)) {
         throw error;
       }
@@ -18694,9 +19101,19 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       this.toolUseStreamCache.clear();
       if (!handedOff) {
         this.session.promptRunning = false;
-        for (const [key, pending] of this.session.pendingMessages) {
-          pending.resolve(true);
-          this.session.pendingMessages.delete(key);
+        if (errored) {
+          for (const pending of this.session.pendingMessages.values()) {
+            pending.resolve(true);
+          }
+          this.session.pendingMessages.clear();
+        } else if (this.session.pendingMessages.size > 0) {
+          const next = [...this.session.pendingMessages.entries()].sort(
+            (a, b) => a[1].order - b[1].order
+          )[0];
+          if (next) {
+            next[1].resolve(false);
+            this.session.pendingMessages.delete(next[0]);
+          }
         }
       }
     }
@@ -18747,7 +19164,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       );
     }
     const mcpServers = parseMcpServers(
-      params
+      params,
+      this.logger
     );
     await this.refreshSession(mcpServers);
     return { refreshed: true };
@@ -18932,7 +19350,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     const settingsManager = new SettingsManager(cwd);
     await settingsManager.initialize();
     const earlyModelId = settingsManager.getSettings().model || meta?.model || "";
-    const mcpServers = supportsMcpInjection(earlyModelId) ? parseMcpServers(params) : {};
+    const mcpServers = supportsMcpInjection(earlyModelId) ? parseMcpServers(params, this.logger) : {};
     const localToolsServer = createLocalToolsMcpServer(
       { cwd, token: resolveGithubToken(), taskId },
       meta
@@ -18956,6 +19374,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       cwd
     });
     const permissionMode = meta?.permissionMode && CODE_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
+    const taskState = /* @__PURE__ */ new Map();
     const options = buildSessionOptions({
       cwd,
       mcpServers,
@@ -18969,7 +19388,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       forkSession,
       additionalDirectories: [
         ...meta?.claudeCode?.options?.additionalDirectories ?? [],
-        ...meta?.additionalRoots ?? []
+        // Prefer the official ACP `additionalDirectories` field. Fall back
+        // to the legacy `_meta.additionalRoots` extension for clients that
+        // haven't been updated yet.
+        ...params.additionalDirectories ?? meta?.additionalRoots ?? []
       ],
       disableBuiltInTools: meta?.disableBuiltInTools,
       outputFormat,
@@ -18980,7 +19402,17 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       effort,
       enrichmentDeps: this.enrichment?.deps,
       enrichedReadCache: this.enrichedReadCache,
-      cloudMode: cloudRun
+      cloudMode: cloudRun,
+      taskState,
+      onTaskStateChange: async () => {
+        await this.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "plan",
+            entries: taskStateToPlanEntries(taskState)
+          }
+        });
+      }
     });
     const abortController = options.abortController;
     const q = query({ prompt: input, options });
@@ -19009,6 +19441,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         systemPrompt: estimateSystemPrompt(systemPrompt),
         rules: estimateRulesTokens(readClaudeMdQuietly(cwd, this.logger))
       },
+      taskState,
       // Custom properties
       cwd,
       notificationHistory: [],
@@ -19027,6 +19460,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             `Session ${forkSession ? "fork" : "resumption"} timed out for sessionId=${sessionId}`
           );
         }
+        session.knownSlashCommands = collectKnownSlashCommands(
+          result.value.commands
+        );
       } catch (err2) {
         settingsManager.dispose();
         if (err2 instanceof Error && err2.message === "Query closed before response received") {
@@ -19045,7 +19481,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       }
     }
     const initPromise2 = !isResume ? withTimeout(q.initializationResult(), SESSION_VALIDATION_TIMEOUT_MS) : void 0;
-    const [modelOptions] = await Promise.all([
+    const [rawModelOptions] = await Promise.all([
       this.getModelConfigOptions(
         settingsManager.getSettings().model || meta?.model || void 0
       ),
@@ -19057,6 +19493,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         })
       ] : []
     ]);
+    const settingsAvailableModels = settingsManager.getSettings().availableModels;
+    const modelOptions = Array.isArray(settingsAvailableModels) ? applyAvailableModelsAllowlist(rawModelOptions, settingsAvailableModels) : rawModelOptions;
     if (initPromise2) {
       try {
         const initResult = await initPromise2;
@@ -19066,6 +19504,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             `Session initialization timed out for sessionId=${sessionId}`
           );
         }
+        session.knownSlashCommands = collectKnownSlashCommands(
+          initResult.value.commands
+        );
       } catch (err2) {
         settingsManager.dispose();
         this.logger.error("Session initialization failed", {
@@ -19077,9 +19518,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         throw err2;
       }
     }
-    const settingsModel = settingsManager.getSettings().model;
-    const metaModel = meta?.model;
-    const resolvedModelId = settingsModel || metaModel || modelOptions.currentModelId;
+    const resolvedModelId = resolveInitialModelId(modelOptions, [
+      settingsManager.getSettings().model,
+      meta?.model
+    ]);
     session.modelId = resolvedModelId;
     session.lastContextWindowSize = this.getContextWindowForModel(resolvedModelId);
     const resolvedSdkModel = toSdkModelId(resolvedModelId);
@@ -19287,6 +19729,34 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       [key]: tokens
     };
   }
+  /**
+   * Rebuild the in-memory taskState from JSONL and push a plan update so the
+   * client's plan panel reflects pre-resume tasks. `loadSession` already covers
+   * this via the full `replaySessionHistory` notification stream; resume
+   * deliberately stays quiet (the client keeps its own message history) so we
+   * walk the transcript here for state only.
+   */
+  async rehydrateTaskStateFromJsonl(sessionId) {
+    try {
+      const messages = await getSessionMessages(sessionId, {
+        dir: this.session.cwd
+      });
+      rehydrateTaskState(messages, this.session.taskState);
+      if (this.session.taskState.size === 0) return;
+      await this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "plan",
+          entries: taskStateToPlanEntries(this.session.taskState)
+        }
+      });
+    } catch (err2) {
+      this.logger.warn("Failed to rehydrate task state", {
+        sessionId,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
+  }
   async replaySessionHistory(sessionId) {
     try {
       const messages = await getSessionMessages(sessionId, {
@@ -20077,7 +20547,7 @@ var CodexAcpAgent = class extends BaseAcpAgent {
     }
     return response;
   }
-  async unstable_resumeSession(params) {
+  async resumeSession(params) {
     const meta = params._meta;
     const injectedParams = this.applyLocalTools(
       this.applyStructuredOutput(