lody 0.76.0 → 0.77.0

package/dist/claude-acp.js

@@ -27,14 +27,14 @@ import path__default from "node:path";
 import * as os$1 from "node:os";
 import os__default from "node:os";
 import process$1 from "node:process";
-import { a as CreateElicitationResponse, n as ndJsonStream, b as agent$1, m as methods, R as RequestError, p as packageJson } from "./chunks/package-C-zjBee4.js";
+import { R as RequestError, a as CreateElicitationResponse, n as ndJsonStream, b as agent$1, m as methods, p as packageJson } from "./chunks/package-qnDHmQq4.js";
 import { execFile as execFile$1 } from "node:child_process";
 import { randomUUID as randomUUID$1 } from "node:crypto";
 import * as fs$2 from "node:fs/promises";
 import { promisify as promisify$1 } from "node:util";
 import * as fs$1 from "node:fs";
 import { WritableStream, ReadableStream as ReadableStream$1 } from "node:stream/web";
-import "./chunks/schemas-DAtmu1t9.js";
+import "./chunks/schemas-Du3qLZPS.js";
 (async () => {
   var wW = Object.create;
   var { getPrototypeOf: TW, defineProperty: $y, getOwnPropertyNames: AW } = Object;
@@ -52928,6 +52928,63 @@ new Anthropic({ apiKey, dangerouslyAllowBrowser: true });
     }
     return null;
   }
+  const GOAL_EXTENSION_VERSION = 1;
+  const GOAL_CONTROL_METHOD = "_session/goal";
+  const GOAL_ACTIONS = [
+    "set",
+    "clear"
+  ];
+  function goalUpdateFromPrompt(prompt) {
+    const match = /^\/goal(?:\s+([\s\S]*))?$/.exec(prompt);
+    const argument = match?.[1]?.trim();
+    if (!argument) {
+      return void 0;
+    }
+    if (argument === "clear") {
+      return null;
+    }
+    return {
+      objective: argument,
+      status: "active",
+      controlMethod: GOAL_CONTROL_METHOD
+    };
+  }
+  function parseGoalRequest(params) {
+    if (!params || typeof params !== "object") {
+      throw RequestError.invalidParams(void 0, "goal params must be an object");
+    }
+    const { sessionId, action, objective } = params;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw RequestError.invalidParams(void 0, "goal params require a non-empty sessionId");
+    }
+    if (!GOAL_ACTIONS.includes(action)) {
+      throw RequestError.invalidParams(void 0, 'goal action must be "set" or "clear"');
+    }
+    if (action === "set" && (typeof objective !== "string" || objective.trim().length === 0)) {
+      throw RequestError.invalidParams(void 0, 'goal action "set" requires a non-empty objective');
+    }
+    return action === "set" ? {
+      sessionId,
+      action,
+      objective: objective.trim()
+    } : {
+      sessionId,
+      action: "clear"
+    };
+  }
+  function toGoalSnapshot(message) {
+    if (message.value === null) {
+      return null;
+    }
+    return {
+      objective: message.value.condition.trim(),
+      status: "active",
+      iterations: message.value.iterations,
+      lastReason: message.value.last_reason ?? null,
+      createdAt: message.value.set_at,
+      controlMethod: GOAL_CONTROL_METHOD
+    };
+  }
   function mcpElicitationToCreateRequest(request, sessionId) {
     if (request.mode === "url") {
       if (!request.url) {
@@ -52984,6 +53041,7 @@ new Anthropic({ apiKey, dangerouslyAllowBrowser: true });
     return `question_${index}_custom`;
   }
   const OPTION_META_KEY = "_claude/askUserQuestionOption";
+  const CUSTOM_ANSWER_META_KEY = "_askUserQuestionCustomAnswer";
   function askUserQuestionsToCreateRequest(questions, sessionId, toolCallId) {
     const single = questions.length === 1;
     const properties = {};
@@ -53023,7 +53081,13 @@ new Anthropic({ apiKey, dangerouslyAllowBrowser: true });
       properties[questionCustomFieldKey(index)] = {
         type: "string",
         title: "Other",
-        description: "Type your own answer instead of choosing an option above (optional)."
+        description: "Type your own answer instead of choosing an option above (optional).",
+        _meta: {
+          [CUSTOM_ANSWER_META_KEY]: {
+            questionId: questionFieldKey(index),
+            isCustomAnswer: true
+          }
+        }
       };
     });
     const requestedSchema = {
@@ -53721,7 +53785,8 @@ ${output}\`\`\``
       }
       case "Bash": {
         const result = toolResult.content;
-        const terminalId = "tool_use_id" in toolResult ? String(toolResult.tool_use_id) : "";
+        const terminalIdOf = (id) => typeof id === "string" && id.length > 0 ? id : void 0;
+        const terminalId = terminalIdOf(toolUse?.id) ?? terminalIdOf("tool_use_id" in toolResult ? toolResult.tool_use_id : void 0);
         const isError = "is_error" in toolResult && toolResult.is_error;
         let output = "";
         let exitCode = isError ? 1 : 0;
@@ -53762,7 +53827,7 @@ ${output}\`\`\``
             return toAcpContentUpdate(result, isError);
           }
         }
-        if (supportsTerminalOutput) {
+        if (supportsTerminalOutput && terminalId !== void 0) {
           return {
             content: [
               {
@@ -53945,25 +54010,26 @@ ${content.text}
   }
   function planEntries(input) {
     return (input?.todos ?? []).map((todo) => ({
-      content: todo.content,
+      content: todo.status === "in_progress" && todo.activeForm ? todo.activeForm : todo.content,
       status: todo.status,
       priority: "medium"
     }));
   }
-  function parseTaskCreateOutput(content) {
+  function parseJsonToolOutput(content, isExpectedOutput) {
     const tryParse = (text) => {
       try {
         const parsed = JSON.parse(text);
-        if (parsed && typeof parsed === "object" && parsed.task && typeof parsed.task.id === "string") {
-          return parsed;
-        }
+        return isExpectedOutput(parsed) ? parsed : void 0;
       } catch {
+        return void 0;
       }
-      return void 0;
     };
     if (typeof content === "string") {
       return tryParse(content);
     }
+    if (content && typeof content === "object" && !Array.isArray(content)) {
+      return isExpectedOutput(content) ? content : void 0;
+    }
     if (Array.isArray(content)) {
       for (const block of content) {
         if (block && typeof block === "object" && "type" in block && block.type === "text") {
@@ -53977,6 +54043,82 @@ ${content.text}
     }
     return void 0;
   }
+  function toolOutputTexts(content) {
+    if (typeof content === "string") return [
+      content
+    ];
+    if (!Array.isArray(content)) return [];
+    return content.flatMap((block) => block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text === "string" ? [
+      block.text
+    ] : []);
+  }
+  function parseTaskCreateOutput(content) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed && typeof parsed === "object" && "task" in parsed && parsed.task && typeof parsed.task === "object" && "id" in parsed.task && typeof parsed.task.id === "string"));
+    if (structured) return structured;
+    for (const text of toolOutputTexts(content)) {
+      const match = /^Task #(\S+) created successfully: (.+)$/.exec(text.trim());
+      if (match) return {
+        task: {
+          id: match[1],
+          subject: match[2]
+        }
+      };
+    }
+    return void 0;
+  }
+  function parseTaskListOutput(content) {
+    const validStatuses = /* @__PURE__ */ new Set([
+      "pending",
+      "in_progress",
+      "completed"
+    ]);
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed && typeof parsed === "object" && "tasks" in parsed && Array.isArray(parsed.tasks) && parsed.tasks.every((task) => task && typeof task === "object" && typeof task.id === "string" && typeof task.subject === "string" && typeof task.status === "string" && validStatuses.has(task.status))));
+    if (structured) return structured;
+    for (const text of toolOutputTexts(content)) {
+      if (text.trim() === "No tasks found") return {
+        tasks: []
+      };
+      const tasks = [];
+      const lines = text.trim().split("\n");
+      for (const line of lines) {
+        const match = /^#(\S+) \[(pending|in_progress|completed)\] (.+?)(?: \(([^()]*)\))?(?: \[blocked by ((?:#[^,\]]+(?:, )?)+)\])?$/.exec(line);
+        if (!match) {
+          tasks.length = 0;
+          break;
+        }
+        tasks.push({
+          id: match[1],
+          subject: match[3],
+          status: match[2],
+          ...match[4] ? {
+            owner: match[4]
+          } : {},
+          blockedBy: match[5] ? match[5].split(", ").map((id) => id.slice(1)) : []
+        });
+      }
+      if (tasks.length > 0) return {
+        tasks
+      };
+    }
+    return void 0;
+  }
+  function parseTaskUpdateOutput(content, expectedTaskId) {
+    const structured = parseJsonToolOutput(content, (parsed) => Boolean(parsed && typeof parsed === "object" && "success" in parsed && typeof parsed.success === "boolean" && "taskId" in parsed && typeof parsed.taskId === "string" && "updatedFields" in parsed && Array.isArray(parsed.updatedFields) && parsed.updatedFields.every((field) => typeof field === "string")));
+    if (structured) return structured;
+    for (const text of toolOutputTexts(content)) {
+      const notFound = /^Task #(\S+) not found$/.exec(text.trim());
+      const taskId = notFound?.[1] ?? expectedTaskId;
+      if (taskId && (notFound || text.trim() === "Failed to delete task")) {
+        return {
+          success: false,
+          taskId,
+          updatedFields: [],
+          error: text.trim()
+        };
+      }
+    }
+    return void 0;
+  }
   function applyTaskCreate(state, input, output) {
     const taskId = output?.task?.id;
     if (!taskId || !input) return;
@@ -54003,9 +54145,22 @@ ${content.text}
       description: input.description ?? existing?.description
     });
   }
+  function applyTaskList(state, output) {
+    const previous = new Map(state);
+    state.clear();
+    for (const task of output.tasks) {
+      const existing = previous.get(task.id);
+      state.set(task.id, {
+        subject: task.subject,
+        status: task.status,
+        activeForm: existing?.activeForm,
+        description: existing?.description
+      });
+    }
+  }
   function taskStateToPlanEntries(state) {
     return Array.from(state.values()).map((task) => ({
-      content: task.subject,
+      content: task.status === "in_progress" && task.activeForm ? task.activeForm : task.subject,
       status: task.status,
       priority: "medium"
     }));
@@ -54458,16 +54613,22 @@ ${content.text}
     if (!params || typeof params !== "object") {
       throw RequestError.invalidParams(void 0, "steer params must be an object");
     }
-    const { sessionId, prompt } = params;
+    const { sessionId, prompt, _meta } = params;
     if (typeof sessionId !== "string" || sessionId.length === 0) {
       throw RequestError.invalidParams(void 0, "steer params require a non-empty sessionId");
     }
     if (!Array.isArray(prompt) || prompt.length === 0) {
       throw RequestError.invalidParams(void 0, "steer params require a non-empty prompt array");
     }
+    const steering = _meta && typeof _meta === "object" ? _meta.steering : void 0;
+    const idleBehavior = steering && typeof steering === "object" ? steering.idleBehavior : void 0;
+    if (idleBehavior !== void 0 && idleBehavior !== "promptRequired") {
+      throw RequestError.invalidParams(void 0, "unsupported steering idleBehavior");
+    }
     return {
       sessionId,
-      prompt
+      prompt,
+      _meta
     };
   }
   function getClientSteerId(meta) {
@@ -54492,6 +54653,9 @@ ${content.text}
   function isHeldOpen(turn) {
     return turn != null && turn.deferredSettle !== void 0 && !turn.settled;
   }
+  function isSteering(turn) {
+    return turn != null && turn.steeredEchoes !== void 0 && !turn.settled;
+  }
   function disarmForceCancel(session) {
     if (session.forceCancelTimer) {
       clearTimeout(session.forceCancelTimer);
@@ -54513,6 +54677,18 @@ ${content.text}
     "bedrock",
     "vertex"
   ];
+  const SUBAGENT_TRANSCRIPT_CAPABILITY = "subagent-transcript";
+  function supportsSubagentTranscript(capabilities) {
+    return capabilities?._meta?.[SUBAGENT_TRANSCRIPT_CAPABILITY] === true;
+  }
+  function parentToolUseIdOf(message) {
+    if (!("parent_tool_use_id" in message)) return null;
+    return typeof message.parent_tool_use_id === "string" ? message.parent_tool_use_id : null;
+  }
+  function stripSubagentTextAndThinking(content) {
+    if (!Array.isArray(content)) return content;
+    return content.filter((item) => !item || typeof item !== "object" || !("type" in item) || item.type !== "text" && item.type !== "thinking");
+  }
   function scanStreamedToolInput(state) {
     let complete = false;
     for (let index = state.scannedTo; index < state.partialJson.length; index++) {
@@ -54696,32 +54872,116 @@ ${content.text}
     }
     return mapped;
   }
-  function describeAlwaysAllow(suggestions, toolName) {
-    if (!suggestions || suggestions.length === 0) {
-      return `Always Allow all ${toolName}`;
+  function permissionLifetime(destination) {
+    switch (destination) {
+      case "session":
+        return {
+          scope: "session"
+        };
+      case "cliArg":
+        return {
+          scope: "process",
+          storage: "cli_argument"
+        };
+      case "userSettings":
+        return {
+          scope: "persistent",
+          storage: "user"
+        };
+      case "projectSettings":
+        return {
+          scope: "persistent",
+          storage: "project"
+        };
+      case "localSettings":
+        return {
+          scope: "persistent",
+          storage: "project_local"
+        };
+      default:
+        return {
+          scope: "unknown"
+        };
     }
-    const ruleLabels = [];
-    const directories = [];
-    for (const update of suggestions) {
-      if (update.type === "addRules" && update.behavior === "allow") {
-        for (const rule of update.rules) {
-          ruleLabels.push(rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : `all ${rule.toolName}`);
+  }
+  function permissionMetadataForAlwaysAllow(suggestions, toolName) {
+    const effectiveSuggestions = suggestions && suggestions.length > 0 ? suggestions : [
+      {
+        type: "addRules",
+        rules: [
+          {
+            toolName
+          }
+        ],
+        behavior: "allow",
+        destination: "session"
+      }
+    ];
+    const changes = [];
+    for (const update of effectiveSuggestions) {
+      switch (update.type) {
+        case "addRules":
+        case "removeRules":
+        case "replaceRules": {
+          const operation = update.type === "addRules" ? "add" : update.type === "removeRules" ? "remove" : "replace";
+          const targets = update.rules.map((rule) => ({
+            type: "tool",
+            toolName: rule.toolName,
+            ...rule.ruleContent ? {
+              matcher: {
+                type: "provider_rule",
+                provider: "claudeCode",
+                value: rule.ruleContent
+              }
+            } : {}
+          }));
+          const renderedRules = update.rules.map((rule) => rule.ruleContent ? `${rule.toolName} calls matching ${rule.ruleContent}` : `all ${rule.toolName} calls`).join(", ");
+          const verb = operation === "add" ? update.behavior === "allow" ? "Allow" : update.behavior === "deny" ? "Deny" : "Ask before" : operation === "remove" ? `Remove ${update.behavior} rules for` : `Replace ${update.behavior} rules with`;
+          changes.push({
+            type: "policy_rule",
+            operation,
+            ruleBehavior: update.behavior,
+            description: `${verb} ${renderedRules}`,
+            lifetime: permissionLifetime(update.destination),
+            targets
+          });
+          break;
         }
-      } else if (update.type === "addDirectories") {
-        directories.push(...update.directories);
+        case "addDirectories":
+        case "removeDirectories": {
+          const operation = update.type === "addDirectories" ? "add" : "remove";
+          changes.push({
+            type: "policy_rule",
+            operation,
+            ruleBehavior: "allow",
+            description: operation === "add" ? `Allow filesystem access under ${update.directories.join(", ")}` : `Remove additional filesystem access under ${update.directories.join(", ")}`,
+            lifetime: permissionLifetime(update.destination),
+            targets: update.directories.map((path2) => ({
+              type: "filesystem",
+              matcher: {
+                type: "directory",
+                path: path2
+              }
+            }))
+          });
+          break;
+        }
+        case "setMode":
+          changes.push({
+            type: "permission_mode",
+            operation: "set",
+            provider: "claudeCode",
+            mode: update.mode,
+            description: `Set Claude Code permission mode to ${update.mode}`,
+            lifetime: permissionLifetime(update.destination)
+          });
+          break;
       }
     }
-    const parts = [];
-    if (ruleLabels.length > 0) {
-      parts.push(ruleLabels.join(", "));
-    }
-    if (directories.length > 0) {
-      parts.push(`access to ${directories.join(", ")}`);
-    }
-    if (parts.length === 0) {
-      return `Always Allow all ${toolName}`;
-    }
-    return `Always Allow ${parts.join(" and ")}`;
+    return {
+      version: 1,
+      changes
+    };
   }
   class ClientConnection {
     ctx;
@@ -54934,6 +55194,13 @@ ${content.text}
         _meta: {
           steering: {
             supported: true
+          },
+          goal: {
+            version: GOAL_EXTENSION_VERSION,
+            controlMethod: GOAL_CONTROL_METHOD,
+            actions: [
+              ...GOAL_ACTIONS
+            ]
           }
         }
       };
@@ -55150,6 +55417,9 @@ ${content.text}
       if (session.queryClosed) {
         throw RequestError.internalError(void 0, SESSION_ENDED_MESSAGE);
       }
+      if (Array.from(session.taskState.values()).some((task) => task.status !== "completed")) {
+        await this.publishTaskPlan(params.sessionId, session.taskState);
+      }
       const userMessage = promptToClaude(params);
       const clientSteerId = getClientSteerId(params._meta);
       if (clientSteerId) {
@@ -55177,11 +55447,87 @@ ${content.text}
       session.turnQueue.push(turn);
       session.input.push(userMessage);
       this.ensureConsumer(session, params.sessionId);
+      await this.publishGoalFromPrompt(params.sessionId, firstText, promptUuid);
       return response;
     }
+    async goal(params) {
+      const command = params.action === "set" ? `/goal ${params.objective}` : "/goal clear";
+      const prompt = [
+        {
+          type: "text",
+          text: command
+        }
+      ];
+      const steering = await this.steer({
+        sessionId: params.sessionId,
+        prompt,
+        _meta: {
+          steering: {
+            idleBehavior: "promptRequired"
+          }
+        }
+      });
+      if (steering.outcome === "promptRequired") {
+        await this.prompt({
+          sessionId: params.sessionId,
+          prompt
+        });
+      }
+      return {};
+    }
+    async publishGoal(sessionId, goal) {
+      const session = this.sessions[sessionId];
+      if (session) {
+        session.lastPublishedGoal = goal;
+      }
+      await this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          _meta: {
+            goal
+          }
+        }
+      });
+    }
+    async publishTaskPlan(sessionId, taskState) {
+      await this.client.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: "plan",
+          entries: taskStateToPlanEntries(taskState)
+        }
+      });
+    }
+    async publishGoalFromPrompt(sessionId, prompt, commandUuid) {
+      const goalUpdate = goalUpdateFromPrompt(prompt);
+      if (goalUpdate !== void 0) {
+        const session = this.sessions[sessionId];
+        if (session) {
+          session.pendingGoalUpdate = {
+            commandUuid,
+            expected: goalUpdate,
+            previous: session.lastPublishedGoal,
+            started: false
+          };
+        }
+        await this.publishGoal(sessionId, goalUpdate);
+      }
+    }
+    async publishRuntimeGoal(sessionId, goal) {
+      const session = this.sessions[sessionId];
+      const pending = session?.pendingGoalUpdate;
+      if (pending) {
+        const matchesPending = pending.expected === null ? goal === null : goal !== null && goal.objective === pending.expected.objective;
+        if (!matchesPending) {
+          return;
+        }
+        session.pendingGoalUpdate = void 0;
+      }
+      await this.publishGoal(sessionId, goal);
+    }
     async steer(params) {
       const sessionId = params.sessionId;
-      const prompt = params.prompt;
       const session = this.sessions[sessionId];
       if (!session) {
         throw new Error("Session not found");
@@ -55189,23 +55535,41 @@ ${content.text}
       if (session.queryClosed) {
         throw RequestError.internalError(void 0, SESSION_ENDED_MESSAGE);
       }
-      const turnInFlight = (session.turnQueue ?? []).some((t) => !t.settled);
-      const promptRequest = {
-        sessionId,
-        prompt
-      };
+      const turnInFlight = (session.turnQueue ?? []).find((turn) => !turn.settled);
       if (!turnInFlight) {
-        this.prompt(promptRequest).catch((error) => {
+        const promptRequest2 = {
+          sessionId,
+          prompt: params.prompt
+        };
+        if (params._meta?.steering?.idleBehavior === "promptRequired") {
+          return {
+            outcome: "promptRequired",
+            reason: "noRunningTurn"
+          };
+        }
+        this.prompt(promptRequest2).catch((error) => {
           this.logger.error(`Session ${sessionId}: steered new turn failed: ${error}`);
         });
         return {
           outcome: "startedNewTurn"
         };
       }
+      const promptRequest = {
+        sessionId,
+        prompt: params.prompt
+      };
       const userMessage = promptToClaude(promptRequest);
-      userMessage.uuid = randomUUID$1();
+      const steeredUuid = randomUUID$1();
+      userMessage.uuid = steeredUuid;
       userMessage.priority = STEER_PRIORITY;
+      (turnInFlight.steeredEchoes ??= /* @__PURE__ */ new Set()).add(steeredUuid);
+      if (turnInFlight.deferredSettle !== void 0) {
+        turnInFlight.steeredSettle = turnInFlight.deferredSettle;
+        turnInFlight.deferredSettle = void 0;
+      }
       session.input.push(userMessage);
+      const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
+      await this.publishGoalFromPrompt(sessionId, firstText, steeredUuid);
       return {
         outcome: "injected"
       };
@@ -55354,6 +55718,10 @@ ${content.text}
         }
       };
       const settleOrDefer = (outcome) => {
+        if (isSteering(session.activeTurn)) {
+          session.activeTurn.steeredSettle = outcome;
+          return;
+        }
         if (session.activeTurn && !session.activeTurn.settled && turnAwaitingSubagents(session.activeTurn)) {
           session.activeTurn.deferredSettle = outcome;
         } else {
@@ -55543,6 +55911,11 @@ ${content.text}
             }
             continue;
           }
+          if (message.type === "active_goal") {
+            const activeGoal = message;
+            await this.publishRuntimeGoal(params.sessionId, toGoalSnapshot(activeGoal));
+            continue;
+          }
           switch (message.type) {
             case "system":
               switch (message.subtype) {
@@ -55550,7 +55923,7 @@ ${content.text}
                   if (message.capabilities?.includes("msg_lifecycle_v1")) {
                     session.msgLifecycleV1 = true;
                   }
-                  await this.syncFastModeState(message.session_id, session, message.fast_mode_state);
+                  await this.syncFastModeState(message.session_id, session, message.fast_mode_state, message.fast_mode_disabled_reason);
                   break;
                 case "status": {
                   if (message.status === "compacting") {
@@ -55640,6 +56013,14 @@ Compacting failed${reason}`
                       settleDeferredIfDrained();
                     } else if (session.owedTrailingIdles > 0) {
                       session.owedTrailingIdles--;
+                    } else if (isSteering(session.activeTurn)) {
+                      const steered = session.activeTurn;
+                      if (steered.steeredEchoes?.size === 0 && steered.steeredSettle !== void 0) {
+                        steered.deferredSettle = steered.steeredSettle;
+                        steered.steeredEchoes = void 0;
+                        steered.steeredSettle = void 0;
+                        settleDeferredIfDrained();
+                      }
                     } else if (!session.cancelled && session.activeTurn && !session.activeTurn.settled) {
                       this.logger.error(`Session ${params.sessionId}: SDK went idle without emitting a result for the active turn; failing the in-flight prompt (issue #825)`);
                       failActive(RequestError.internalError(errorKindData("no_result"), TURN_NO_RESULT_MESSAGE));
@@ -55704,6 +56085,10 @@ Compacting failed${reason}`
                   break;
                 }
                 case "permission_denied": {
+                  if (!session.emittedToolCalls.has(message.tool_use_id)) {
+                    break;
+                  }
+                  const parentToolUseId = message.agent_id ? session.liveBackgroundTasks.get(message.agent_id)?.parentToolUseId : void 0;
                   const reason = message.decision_reason ?? message.message;
                   await sendUpdate({
                     sessionId: message.session_id,
@@ -55723,6 +56108,9 @@ Compacting failed${reason}`
                       _meta: {
                         claudeCode: {
                           toolName: message.tool_name,
+                          ...parentToolUseId ? {
+                            parentToolUseId
+                          } : {},
                           toolResponse: {
                             decisionReasonType: message.decision_reason_type,
                             decisionReason: message.decision_reason,
@@ -55849,14 +56237,23 @@ ${message.api_refusal_explanation}` : "";
               const isAutonomousResult = message.origin != null && AUTONOMOUS_RESULT_ORIGINS.has(message.origin.kind);
               try {
                 if (!isAutonomousResult) {
-                  await this.syncFastModeState(params.sessionId, session, message.fast_mode_state);
+                  await this.syncFastModeState(params.sessionId, session, message.fast_mode_state, message.fast_mode_disabled_reason);
                 }
                 if (!isAutonomousResult) {
                   recordResultForOrphanCommands();
                   await ensureActiveTurn();
+                  if (session.pendingGoalUpdate?.started) {
+                    const pendingGoalUpdate = session.pendingGoalUpdate;
+                    session.pendingGoalUpdate = void 0;
+                    const goalCommandFailed = message.is_error || message.stop_reason === "refusal" || "result" in message && message.result.includes("Please run /login");
+                    if (goalCommandFailed) {
+                      await this.publishGoal(params.sessionId, pendingGoalUpdate.previous ?? null);
+                    }
+                  }
                 }
                 const deliveredAssistantText = session.emittedAssistantText;
-                if (isAutonomousResult || !session.cancelled || !session.activeTurn) {
+                const owesTrailingIdle = isAutonomousResult || !isSteering(session.activeTurn);
+                if (owesTrailingIdle && (isAutonomousResult || !session.cancelled || !session.activeTurn)) {
                   session.owedTrailingIdles++;
                 }
                 if (!isAutonomousResult) {
@@ -55954,6 +56351,13 @@ ${message.api_refusal_explanation}` : "";
                   });
                   break;
                 }
+                if (message.is_error && isSteering(session.activeTurn) && session.activeTurn.steeredEchoes.size > 0) {
+                  settleOrDefer({
+                    stopReason: "end_turn",
+                    usage: sessionUsage(session)
+                  });
+                  break;
+                }
                 switch (message.subtype) {
                   case "success": {
                     if (message.result.includes("Please run /login")) {
@@ -56094,6 +56498,9 @@ ${message.api_refusal_explanation}` : "";
             case "user":
             case "assistant": {
               if (message.type === "user" && "uuid" in message && message.uuid) {
+                if (session.pendingGoalUpdate?.commandUuid === message.uuid) {
+                  session.pendingGoalUpdate.started = true;
+                }
                 const queued = findUnsettledTurn(message.uuid);
                 if (queued) {
                   if (session.activeTurn !== queued) {
@@ -56106,6 +56513,9 @@ ${message.api_refusal_explanation}` : "";
                         });
                       } else if (isHeldOpen(session.activeTurn)) {
                         settleActive(session.activeTurn.deferredSettle);
+                      } else if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
+                        session.owedTrailingIdles++;
+                        settleActive(session.activeTurn.steeredSettle);
                       } else {
                         settleActive({
                           stopReason: "end_turn",
@@ -56118,6 +56528,9 @@ ${message.api_refusal_explanation}` : "";
                   break;
                 }
                 if ("isReplay" in message && message.isReplay) {
+                  if (isSteering(session.activeTurn)) {
+                    session.activeTurn.steeredEchoes.delete(message.uuid);
+                  }
                   break;
                 }
               }
@@ -56201,7 +56614,7 @@ ${message.api_refusal_explanation}` : "";
                 }
                 content = kept;
                 streamedBlocks.length = 0;
-              } else if (message.type === "assistant") {
+              } else if (message.type === "assistant" && !(session.forwardSubagentText || supportsSubagentTranscript(this.clientCapabilities))) {
                 content = message.message.content.filter((item) => item.type !== "text" && item.type !== "thinking");
               } else {
                 content = message.message.content;
@@ -56224,11 +56637,15 @@ ${message.api_refusal_explanation}` : "";
               break;
             }
             case "tool_progress": {
+              const toolCallId = session.emittedToolCalls.has(message.tool_use_id) ? message.tool_use_id : message.parent_tool_use_id;
+              if (toolCallId === null || !session.emittedToolCalls.has(toolCallId)) {
+                break;
+              }
               await sendUpdate({
                 sessionId: message.session_id,
                 update: {
                   sessionUpdate: "tool_call_update",
-                  toolCallId: message.tool_use_id,
+                  toolCallId,
                   status: "in_progress",
                   _meta: {
                     claudeCode: {
@@ -56264,10 +56681,14 @@ ${message.api_refusal_explanation}` : "";
               }
               break;
             }
+            case "conversation_reset": {
+              session.taskState.clear();
+              await this.publishTaskPlan(params.sessionId, session.taskState);
+              break;
+            }
             case "tool_use_summary":
             case "auth_status":
             case "prompt_suggestion":
-            case "conversation_reset":
               break;
             default:
               unreachable(message, this.logger);
@@ -56306,6 +56727,11 @@ ${message.api_refusal_explanation}` : "";
         return;
       }
       session.cancelled = true;
+      if (isSteering(session.activeTurn)) {
+        for (const uuid of session.activeTurn.steeredEchoes) {
+          this.trackOrphanCommand(session, uuid, "pending");
+        }
+      }
       const lifecycleLane = session.msgLifecycleV1 === true;
       const orphanedTurns = [];
       if (session.turnQueue) {
@@ -56352,6 +56778,9 @@ ${message.api_refusal_explanation}` : "";
           });
         }
       }
+      if (isSteering(session.activeTurn) && session.activeTurn.steeredSettle !== void 0) {
+        session.owedTrailingIdles++;
+      }
       if (session.activeTurn && session.cancelController && !session.cancelController.signal.aborted && !session.forceCancelTimer) {
         const cancelController = session.cancelController;
         session.forceCancelTimer = setTimeout(() => {
@@ -56529,12 +56958,17 @@ ${message.api_refusal_explanation}` : "";
     async replaySessionHistory(sessionId) {
       const toolUseCache = {};
       const messages = await Rkt(sessionId);
+      const forwardSubagentText = this.sessions[sessionId]?.forwardSubagentText ?? supportsSubagentTranscript(this.clientCapabilities);
       for (const message of messages) {
         const replayMessageId = messageIdForGrouping(message);
         if (message.type === "assistant" && isSyntheticLoginMessage(message.message)) {
           continue;
         }
         let content = message.message.content;
+        const parentToolUseId = parentToolUseIdOf(message);
+        if (message.type === "assistant" && parentToolUseId && !forwardSubagentText) {
+          content = stripSubagentTextAndThinking(content);
+        }
         if (message.message.role === "user") {
           content = stripLocalCommandMetadata(content);
           if (content === null) continue;
@@ -56544,7 +56978,8 @@ ${message.api_refusal_explanation}` : "";
           clientCapabilities: this.clientCapabilities,
           cwd: this.sessions[sessionId]?.cwd,
           taskState: this.sessions[sessionId]?.taskState,
-          messageId: replayMessageId
+          messageId: replayMessageId,
+          parentToolUseId
         })) {
           await this.client.sessionUpdate(notification);
         }
@@ -56605,7 +57040,6 @@ ${message.api_refusal_explanation}` : "";
     }
     canUseTool(sessionId) {
       return async (toolName, toolInput, { signal, suggestions, toolUseID, agentID, matchedAskRule }) => {
-        const alwaysAllowLabel = describeAlwaysAllow(suggestions, toolName);
         const supportsTerminalOutput = this.clientCapabilities?._meta?.["terminal_output"] === true;
         const session = this.sessions[sessionId];
         if (!session) {
@@ -56616,7 +57050,7 @@ ${message.api_refusal_explanation}` : "";
         }
         const parentToolUseId = agentID ? session.liveBackgroundTasks.get(agentID)?.parentToolUseId : void 0;
         if (agentID && !parentToolUseId) {
-          this.logger.log(`[claude-agent-acp] No parent tool_use recorded for subagent ${agentID}; sending the ${toolName} permission request unattributed`);
+          this.logger.log(`[acp-extension-claude] No parent tool_use recorded for subagent ${agentID}; sending the ${toolName} permission request unattributed`);
         }
         if (toolName === "AskUserQuestion" && this.clientCapabilities?.elicitation?.form) {
           await this.ensureToolCallEmitted(sessionId, toolName, toolUseID, toolInput, parentToolUseId);
@@ -56727,19 +57161,22 @@ ${message.api_refusal_explanation}` : "";
         const response = await this.requestPermissionFromClient({
           options: [
             {
-              kind: "allow_always",
-              name: alwaysAllowLabel,
-              optionId: "allow_always"
+              kind: "reject_once",
+              name: "Deny",
+              optionId: "reject"
             },
             {
               kind: "allow_once",
-              name: "Allow",
+              name: "Allow Once",
               optionId: "allow"
             },
             {
-              kind: "reject_once",
-              name: "Reject",
-              optionId: "reject"
+              kind: "allow_always",
+              name: "Always Allow",
+              optionId: "allow_always",
+              _meta: {
+                permission: permissionMetadataForAlwaysAllow(suggestions, toolName)
+              }
             }
           ],
           sessionId,
@@ -56970,12 +57407,16 @@ ${message.api_refusal_explanation}` : "";
             availableModes: newAvailableModes
           };
         }
+        if (session.fastModeDisabledReason === "model_not_allowed") {
+          session.fastModeDisabledReason = void 0;
+        }
         const effortOpt = session.configOptions.find((o) => o.id === EFFORT_CONFIG_ID);
         const currentEffort = typeof effortOpt?.currentValue === "string" ? effortOpt.currentValue : void 0;
         session.configOptions = buildConfigOptions(session.modes, session.models, session.modelInfos, currentEffort, session.agents, session.currentAgent, {
           supported: newModelInfo?.supportsFastMode ?? false,
           enabled: session.fastModeEnabled,
-          useBooleanOption: clientSupportsBooleanConfigOptions(this.clientCapabilities)
+          useBooleanOption: clientSupportsBooleanConfigOptions(this.clientCapabilities),
+          disabledReason: session.fastModeDisabledReason
         });
         const newEffortOpt = session.configOptions.find((o) => o.id === EFFORT_CONFIG_ID);
         const newEffort = typeof newEffortOpt?.currentValue === "string" ? newEffortOpt.currentValue : void 0;
@@ -57025,7 +57466,7 @@ ${message.api_refusal_explanation}` : "";
       }
     }
     refreshFastModeOption(session, enabled) {
-      const refreshed = createFastModeConfigOption(enabled, clientSupportsBooleanConfigOptions(this.clientCapabilities));
+      const refreshed = createFastModeConfigOption(enabled, clientSupportsBooleanConfigOptions(this.clientCapabilities), session.fastModeDisabledReason);
       session.configOptions = session.configOptions.map((o) => o.id === FAST_MODE_CONFIG_ID ? refreshed : o);
     }
     async applyFastMode(session, enabled) {
@@ -57035,7 +57476,7 @@ ${message.api_refusal_explanation}` : "";
       session.fastModeEnabled = enabled;
       this.refreshFastModeOption(session, enabled);
     }
-    async syncFastModeState(sessionId, session, state) {
+    async syncFastModeState(sessionId, session, state, reason) {
       if (state === void 0) {
         return;
       }
@@ -57046,11 +57487,26 @@ ${message.api_refusal_explanation}` : "";
         return;
       }
       const enabled = state === "on";
-      if (enabled === session.fastModeEnabled) {
+      const nextReason = enabled ? void 0 : normalizeFastModeDisabledReason(reason);
+      if (enabled === session.fastModeEnabled && nextReason === session.fastModeDisabledReason) {
         return;
       }
+      const explain = session.fastModeEnabled && !enabled && nextReason !== void 0;
       session.fastModeEnabled = enabled;
+      session.fastModeDisabledReason = nextReason;
       this.refreshFastModeOption(session, enabled);
+      if (explain) {
+        await this.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: `**Fast mode turned off:** ${FAST_MODE_UNAVAILABLE_EXPLANATIONS[nextReason]}.`
+            }
+          }
+        });
+      }
       await this.client.sessionUpdate({
         sessionId,
         update: {
@@ -57165,6 +57621,7 @@ ${message.api_refusal_explanation}` : "";
       const permissionMode = resolvePermissionMode(settingsManager.getSettings().permissions?.defaultMode, this.logger);
       const sessionMeta = params._meta;
       const userProvidedOptions = sessionMeta?.claudeCode?.options;
+      const forwardSubagentText = supportsSubagentTranscript(this.clientCapabilities) || userProvidedOptions?.forwardSubagentText === true;
       const thinking = resolveThinkingConfig(process.env.MAX_THINKING_TOKENS, this.logger);
       const modelConfig = parseModelConfig(process.env.CLAUDE_MODEL_CONFIG);
       const elicitationSupport = {
@@ -57211,6 +57668,7 @@ ${message.api_refusal_explanation}` : "";
         env,
         cwd: params.cwd,
         includePartialMessages: true,
+        forwardSubagentText,
         mcpServers: {
           ...userProvidedOptions?.mcpServers || {},
           ...mcpServers
@@ -57264,15 +57722,7 @@ ${message.api_refusal_explanation}` : "";
               hooks: [
                 createTaskHook({
                   taskState,
-                  onChange: async () => {
-                    await this.client.sessionUpdate({
-                      sessionId,
-                      update: {
-                        sessionUpdate: "plan",
-                        entries: taskStateToPlanEntries(taskState)
-                      }
-                    });
-                  }
+                  onChange: () => this.publishTaskPlan(sessionId, taskState)
                 })
               ]
             }
@@ -57283,15 +57733,7 @@ ${message.api_refusal_explanation}` : "";
               hooks: [
                 createTaskHook({
                   taskState,
-                  onChange: async () => {
-                    await this.client.sessionUpdate({
-                      sessionId,
-                      update: {
-                        sessionUpdate: "plan",
-                        entries: taskStateToPlanEntries(taskState)
-                      }
-                    });
-                  }
+                  onChange: () => this.publishTaskPlan(sessionId, taskState)
                 })
               ]
             }
@@ -57367,10 +57809,12 @@ ${message.api_refusal_explanation}` : "";
       const requestedAgent = userProvidedOptions?.agent;
       const currentAgent = requestedAgent && agents.some((a) => a.name === requestedAgent) ? requestedAgent : DEFAULT_AGENT_ID;
       const fastModeEnabled = initializationResult.fast_mode_state !== void 0 && fastModeStateEnabled(initializationResult.fast_mode_state);
+      const fastModeDisabledReason = fastModeEnabled ? void 0 : normalizeFastModeDisabledReason(initializationResult.fast_mode_disabled_reason);
       const fastMode = {
         supported: currentModelInfo?.supportsFastMode ?? false,
         enabled: fastModeEnabled,
-        useBooleanOption: clientSupportsBooleanConfigOptions(this.clientCapabilities)
+        useBooleanOption: clientSupportsBooleanConfigOptions(this.clientCapabilities),
+        disabledReason: fastModeDisabledReason
       };
       const configOptions = buildConfigOptions(modes, models, modelInfos, settingsManager.getSettings().effortLevel, agents, currentAgent, fastMode);
       const initialEffort = configOptions.find((o) => o.id === EFFORT_CONFIG_ID);
@@ -57403,8 +57847,10 @@ ${message.api_refusal_explanation}` : "";
         agents,
         currentAgent,
         fastModeEnabled,
+        fastModeDisabledReason,
         abortController,
         emitRawSDKMessages: sessionMeta?.claudeCode?.emitRawSDKMessages ?? false,
+        forwardSubagentText,
         contextWindowSize: seededWindow.size,
         contextWindowAuthoritative: seededWindow.authoritative,
         providerCacheKey,
@@ -57567,14 +58013,26 @@ ${message.api_refusal_explanation}` : "";
   function fastModeStateEnabled(state) {
     return state !== "off";
   }
+  const FAST_MODE_UNAVAILABLE_EXPLANATIONS = {
+    free: "not available on the free plan",
+    extra_usage_disabled: "requires extra usage to be enabled for this account",
+    model_not_allowed: "not available for the selected model",
+    not_first_party: "not available on this API provider",
+    disabled_by_env: "disabled by environment configuration",
+    network_error: "eligibility could not be verified (network error)"
+  };
+  function normalizeFastModeDisabledReason(reason) {
+    return reason && FAST_MODE_UNAVAILABLE_EXPLANATIONS[reason] ? reason : void 0;
+  }
   function clientSupportsBooleanConfigOptions(clientCapabilities) {
     return clientCapabilities?.session?.configOptions?.boolean != null;
   }
-  function createFastModeConfigOption(enabled, useBooleanOption) {
+  function createFastModeConfigOption(enabled, useBooleanOption, disabledReason) {
+    const explanation = enabled ? void 0 : disabledReason && FAST_MODE_UNAVAILABLE_EXPLANATIONS[disabledReason];
     const base = {
       id: FAST_MODE_CONFIG_ID,
       name: "Fast mode",
-      description: FAST_MODE_DESCRIPTION,
+      description: explanation ? `${FAST_MODE_DESCRIPTION} \u2014 ${explanation}` : FAST_MODE_DESCRIPTION,
       category: "model_config"
     };
     if (useBooleanOption) {
@@ -57668,7 +58126,7 @@ ${message.api_refusal_explanation}` : "";
       });
     }
     if (fastMode?.supported) {
-      options.push(createFastModeConfigOption(fastMode.enabled, fastMode.useBooleanOption));
+      options.push(createFastModeConfigOption(fastMode.enabled, fastMode.useBooleanOption, fastMode.disabledReason));
     }
     if (agents.length > 0) {
       options.push({
@@ -58069,13 +58527,23 @@ ${chunk.resource.text}
   function shouldEmitToolCall(toolName) {
     return toolName !== "TodoWrite" && !isTaskTool(toolName);
   }
+  function claudeCodeMetaFromToolUse(toolUse) {
+    const description = toolUse.name === "Bash" && toolUse.input !== null && typeof toolUse.input === "object" && "description" in toolUse.input && typeof toolUse.input.description === "string" ? toolUse.input.description : void 0;
+    return {
+      toolName: toolUse.name,
+      ...description ? {
+        title: description
+      } : {},
+      ...(toolUse.name === "Agent" || toolUse.name === "Task") && {
+        subagent: true
+      }
+    };
+  }
   function toolCallNotification(toolUse, rawInput, supportsTerminalOutput, cwd2, refine = false) {
     if (refine) {
       return {
         _meta: {
-          claudeCode: {
-            toolName: toolUse.name
-          }
+          claudeCode: claudeCodeMetaFromToolUse(toolUse)
         },
         toolCallId: toolUse.id,
         sessionUpdate: "tool_call_update",
@@ -58085,9 +58553,7 @@ ${chunk.resource.text}
     }
     return {
       _meta: {
-        claudeCode: {
-          toolName: toolUse.name
-        },
+        claudeCode: claudeCodeMetaFromToolUse(toolUse),
         ...toolUse.name === "Bash" && supportsTerminalOutput ? {
           terminal_info: {
             terminal_id: toolUse.id
@@ -58111,9 +58577,10 @@ ${chunk.resource.text}
     }, supportsTerminalOutput, cwd2);
     return {
       _meta: {
-        claudeCode: {
-          toolName: toolUse.name
-        }
+        claudeCode: claudeCodeMetaFromToolUse({
+          ...toolUse,
+          input
+        })
       },
       toolCallId: toolUse.id,
       sessionUpdate: "tool_call_update",
@@ -58299,7 +58766,7 @@ ${chunk.resource.text}
                 }
               });
             }
-            logger.error(`[claude-agent-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`);
+            logger.error(`[acp-extension-claude] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`);
             break;
           }
           if (wasEmitted && !shouldEmitToolCall(toolUse.name)) {
@@ -58324,14 +58791,27 @@ ${chunk.resource.text}
           }
           if (isTaskTool(toolUse.name)) {
             const isError = "is_error" in chunk && chunk.is_error;
+            let shouldEmitTaskPlan = false;
             if (!isError) {
               if (toolUse.name === "TaskCreate") {
-                applyTaskCreate(taskState, toolUse.input, parseTaskCreateOutput(chunk.content));
+                applyTaskCreate(taskState, toolUse.input, parseTaskCreateOutput(toolUseResult) ?? parseTaskCreateOutput(chunk.content));
+                shouldEmitTaskPlan = true;
               } else if (toolUse.name === "TaskUpdate") {
-                applyTaskUpdate(taskState, toolUse.input);
+                const input = toolUse.input;
+                const output2 = parseTaskUpdateOutput(toolUseResult, input?.taskId) ?? parseTaskUpdateOutput(chunk.content, input?.taskId);
+                if (!output2 || output2.success && output2.taskId === input?.taskId) {
+                  applyTaskUpdate(taskState, input);
+                  shouldEmitTaskPlan = true;
+                }
+              } else if (toolUse.name === "TaskList") {
+                const output2 = parseTaskListOutput(toolUseResult) ?? parseTaskListOutput(chunk.content);
+                if (output2) {
+                  applyTaskList(taskState, output2);
+                  shouldEmitTaskPlan = true;
+                }
               }
             }
-            if (!isError && (toolUse.name === "TaskCreate" || toolUse.name === "TaskUpdate")) {
+            if (shouldEmitTaskPlan) {
               update = {
                 sessionUpdate: "plan",
                 entries: taskStateToPlanEntries(taskState)
@@ -58535,7 +59015,9 @@ ${chunk.resource.text}
       name: "claude-code-acp"
     }).onRequest(methods.agent.initialize, (ctx) => agent2.initialize(ctx.params)).onRequest(methods.agent.session.new, (ctx) => agent2.newSession(ctx.params)).onRequest(methods.agent.session.load, (ctx) => agent2.loadSession(ctx.params)).onRequest(methods.agent.session.fork, (ctx) => agent2.unstable_forkSession(ctx.params)).onRequest(methods.agent.session.list, (ctx) => agent2.listSessions(ctx.params)).onRequest(methods.agent.session.delete, (ctx) => agent2.deleteSession(ctx.params)).onRequest(methods.agent.session.resume, (ctx) => agent2.resumeSession(ctx.params)).onRequest(methods.agent.session.close, (ctx) => agent2.closeSession(ctx.params)).onRequest(methods.agent.session.setMode, (ctx) => agent2.setSessionMode(ctx.params)).onRequest(methods.agent.session.setConfigOption, (ctx) => agent2.setSessionConfigOption(ctx.params)).onRequest(methods.agent.authenticate, (ctx) => agent2.authenticate(ctx.params)).onRequest(methods.agent.providers.list, (ctx) => agent2.unstable_listProviders(ctx.params)).onRequest(methods.agent.providers.set, (ctx) => agent2.unstable_setProvider(ctx.params)).onRequest(methods.agent.providers.disable, (ctx) => agent2.unstable_disableProvider(ctx.params)).onRequest(methods.agent.logout, (ctx) => agent2.logout(ctx.params)).onRequest(methods.agent.session.prompt, (ctx) => runPromptWithCancellation(agent2, ctx.params, ctx.signal)).onNotification(methods.agent.session.cancel, (ctx) => agent2.cancel(ctx.params)).onRequest(STEER_METHOD, {
       parse: parseSteerRequest
-    }, (ctx) => agent2.steer(ctx.params)).connect(stream);
+    }, (ctx) => agent2.steer(ctx.params)).onRequest(GOAL_CONTROL_METHOD, {
+      parse: parseGoalRequest
+    }, (ctx) => agent2.goal(ctx.params)).connect(stream);
     agent2 = new ClaudeAcpAgent(new ClientConnection(connection2.client));
     return {
       connection: connection2,