@qwen-code/qwen-code 0.21.2-nightly.20260801.bc382c3ff → 0.21.3

package/chunks/{chunk-NGWYUZZO.js → chunk-UQDFEU47.js}

@@ -40,7 +40,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-CWEIMFFW.js";
+} from "./chunk-VA5NLVPT.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -71,13 +71,13 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-PXA5AWHY.js";
+} from "./chunk-XUMAD5IT.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-MYT7N6QH.js";
+} from "./chunk-X6QNZOTC.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -139,15 +139,42 @@ import {
   goalRequiresExactPermit,
   goalTurnContext,
   parseGoalStateRecordPayloadV2
-} from "./chunk-6FMJLI5M.js";
+} from "./chunk-HFVW54NL.js";
 import {
   APPROVAL_MODES,
+  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
+  buildSubagentPlanToolBlockedResult,
+  childLaunchDepth,
+  getCurrentAgentDepth,
+  getCurrentAgentId,
+  getLeaderOnlyToolUnavailableMessage,
+  getPlanRequiredTeammatePreApprovalMessage,
+  getRuntimeContentGenerator,
+  getSubagentPlanToolUnavailableMessage,
+  isLeaderOnlyToolUnavailableInSubagent,
+  isPlanLifecycleToolUnavailableInSubagent,
+  isPlanRequiredTeammateAwaitingApproval,
+  isPlanRequiredTeammateContext,
+  isPlanRequiredTeammatePreApprovalAllowedTool,
+  isSubagentLikeExecutionContext,
+  isTopLevelSession,
+  runOutsideAgentContext,
+  runWithAgentContext,
+  runWithRuntimeContentGenerator,
+  shouldUsePlanOnlyReminderInSubagentContext,
+  spawnBlockReason
+} from "./chunk-TZTBZ25J.js";
+import {
+  getTeammateContext,
+  isTeammate,
+  runWithTeammateIdentity
+} from "./chunk-S6LOFUVP.js";
+import {
   BUBBLE_APPROVAL_MODE,
   FORK_AGENT,
   FORK_DEFAULT_MAX_TURNS,
   FORK_PLACEHOLDER_RESULT,
   FORK_SUBAGENT_TYPE,
-  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   SubagentError,
   SubagentErrorCode,
   buildAvailableSkillsReminder,
@@ -161,44 +188,21 @@ import {
   buildFunctionResponseParts,
   buildMcpServerInstructionsReminder,
   buildPinnedWorktreeNotice,
-  buildSubagentPlanToolBlockedResult,
   buildWorktreeNotice,
-  childLaunchDepth,
   formatDateForContext,
-  getCurrentAgentDepth,
-  getCurrentAgentId,
   getDirectoryContextString,
   getFolderStructure,
   getInitialChatHistory,
-  getLeaderOnlyToolUnavailableMessage,
-  getPlanRequiredTeammatePreApprovalMessage,
-  getRuntimeContentGenerator,
   getStartupContextLength,
-  getSubagentPlanToolUnavailableMessage,
-  isLeaderOnlyToolUnavailableInSubagent,
-  isPlanLifecycleToolUnavailableInSubagent,
-  isPlanRequiredTeammateAwaitingApproval,
-  isPlanRequiredTeammateContext,
-  isPlanRequiredTeammatePreApprovalAllowedTool,
-  isSubagentLikeExecutionContext,
   isSystemReminderContent,
-  isTopLevelSession,
   normalizeForkTurns,
+  registerForkDisplayImageForCache,
+  resolveForkExecutionAllowedTools,
   runInForkContext,
-  runOutsideAgentContext,
-  runWithAgentContext,
-  runWithRuntimeContentGenerator,
   selectForkHistory,
-  shouldUsePlanOnlyReminderInSubagentContext,
-  spawnBlockReason,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-PGEGUNH5.js";
-import {
-  getTeammateContext,
-  isTeammate,
-  runWithTeammateIdentity
-} from "./chunk-S6LOFUVP.js";
+} from "./chunk-SRY26X4H.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -376,7 +380,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-M2F5PLOW.js";
+} from "./chunk-4K3RV3OA.js";
 import {
   E_TIMEOUT,
   Mutex,
@@ -404,7 +408,7 @@ import {
 } from "./chunk-E4WHKETF.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-BV4QX43X.js";
+} from "./chunk-UEJESCS7.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -421,7 +425,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-I5GNT6ZS.js";
+} from "./chunk-CFDR3GNL.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
@@ -435,7 +439,7 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-TFFMATHX.js";
+} from "./chunk-H35Q5CEG.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -22128,6 +22132,7 @@ You have access to the ${ToolNames.TODO_WRITE} tool to keep user-visible progres
 
 When you create a todo list:
 - Keep it short and outcome-oriented. Use a few meaningful, logically ordered, verifiable steps rather than one item per error, file, command, or minor edit.
+- For complex work delegated through top-level Agent calls, create the relevant todo first and pass its ID as \`todo_id\` so the execution can be associated with the plan node.
 - Keep at most one item in_progress. Keep the list current, mark finished work completed, and revise it when the scope or approach changes. When work completes together, update multiple statuses in one tool call rather than making bookkeeping-only calls.
 - Do not repeat the full todo list in prose after calling the tool; briefly communicate only important context or the next step.
 
@@ -35779,7 +35784,6 @@ var ChatCompressionService = class {
     const {
       promptId,
       force,
-      model,
       config,
       consecutiveFailures,
       originalTokenCount,
@@ -35889,10 +35893,37 @@ var ChatCompressionService = class {
         `[chat-compression] slimmed ${slim.stats.imagesStripped} image(s) and ${slim.stats.documentsStripped} document(s) from side-query payload`
       );
     }
+    const systemInstruction = buildCompressionSystemPrompt(
+      opts.customInstructions,
+      hookExtraInstructions
+    );
+    let effectiveCompactionModel = config.getCompactionModel?.() ?? config.getModel();
+    let compactionWarning;
+    if (effectiveCompactionModel !== config.getModel()) {
+      const resolved = resolveModelId(effectiveCompactionModel);
+      if (resolved) {
+        const models = resolved.authType ? config.getAllConfiguredModels([resolved.authType]) : config.getAllConfiguredModels();
+        const entry = models.find((m2) => m2.id === resolved.modelId);
+        const window2 = entry?.contextWindowSize;
+        const slimmedTokenEstimate = estimateContentTokens(
+          slim.slimmedHistory,
+          slimmingConfig.imageTokenEstimate
+        ) + Math.ceil(systemInstruction.length / CHARS_PER_TOKEN) + COMPACT_MAX_OUTPUT_TOKENS;
+        if (window2 && window2 > 0 && slimmedTokenEstimate > window2) {
+          compactionWarning = `Compaction model "${resolved.modelId}" context window (${window2.toLocaleString()} tokens) is too small for the current payload (~${slimmedTokenEstimate.toLocaleString()} tokens); using the main model for this compression.`;
+          config.getDebugLogger().warn(`[chat-compression] ${compactionWarning}`);
+          effectiveCompactionModel = config.getModel();
+        }
+      }
+    }
     const summaryResult = await runSideQuery(config, {
       purpose: "chat-compression",
       skipOutputLanguagePreference: true,
-      model,
+      model: effectiveCompactionModel,
+      // Compression uses the compaction model (config.getCompactionModel?.()) to reduce cost.
+      // Falls back to the main model if not set or if the payload exceeds the
+      // compaction model's context window.
+      // See https://github.com/QwenLM/qwen-code/issues/5956
       // Stream so a slow compression inference keeps the HTTP connection alive.
       // Non-streaming returns no bytes until the whole summary is generated, so
       // behind a BFF gateway with a short `proxy_read_timeout` a long inference
@@ -35902,10 +35933,7 @@ var ChatCompressionService = class {
       // Best-effort: failures fall back to NOOP and the next turn re-triggers
       // compression anyway, so don't burn 7 retries blocking the user mid-turn.
       maxAttempts: 1,
-      systemInstruction: buildCompressionSystemPrompt(
-        opts.customInstructions,
-        hookExtraInstructions
-      ),
+      systemInstruction,
       contents: [
         ...slim.slimmedHistory,
         {
@@ -36101,7 +36129,8 @@ var ChatCompressionService = class {
           originalTokenCount,
           newTokenCount,
           compressionStatus: 1 /* COMPRESSED */,
-          triggerReason
+          triggerReason,
+          ...compactionWarning && { warning: compactionWarning }
         }
       };
     }
@@ -37625,12 +37654,11 @@ var GeminiChat = class {
    * Deferred callers are responsible for recording after their own
    * post-compression guards pass.
    */
-  async tryCompress(promptId, model, force = false, signal, options2) {
+  async tryCompress(promptId, force = false, signal, options2) {
     const service = new ChatCompressionService();
     const { newHistory, info } = await service.compress(this, {
       promptId,
       force,
-      model,
       config: this.config,
       consecutiveFailures: this.consecutiveFailures,
       originalTokenCount: options2?.originalTokenCountOverride ?? this.lastPromptTokenCount,
@@ -37860,7 +37888,6 @@ var GeminiChat = class {
       } else {
         compressionInfo = await this.tryCompress(
           prompt_id,
-          model,
           shouldForceFromHard,
           params.config?.abortSignal,
           {
@@ -38178,7 +38205,6 @@ var GeminiChat = class {
                 try {
                   const reactiveInfo = await self2.tryCompress(
                     prompt_id,
-                    model,
                     true,
                     params.config?.abortSignal,
                     {
@@ -49207,6 +49233,7 @@ var ModelRegistry = class {
       envKey: model.envKey,
       fastOnly: model.fastOnly,
       voiceOnly: model.voiceOnly,
+      visionOnly: model.visionOnly,
       imageOnly: model.imageOnly
     }));
   }
@@ -49286,6 +49313,7 @@ var ModelRegistry = class {
     const selectorOnlyCount = [
       config.fastOnly,
       config.voiceOnly,
+      config.visionOnly,
       config.imageOnly
     ].filter(Boolean).length;
     if (selectorOnlyCount > 1) {
@@ -81950,6 +81978,7 @@ var WorkflowRunRegistry = class {
   registerCallback;
   statusChangeCallback;
   notificationCallback;
+  completionCallback;
   approvalChangeCallback;
   approvalRequestCallback;
   approvalRuntimes = /* @__PURE__ */ new Map();
@@ -81985,6 +82014,12 @@ var WorkflowRunRegistry = class {
   setNotificationCallback(cb) {
     this.notificationCallback = cb;
   }
+  setCompletionCallback(cb) {
+    this.completionCallback = cb;
+  }
+  hasCompletionCallback() {
+    return this.completionCallback !== void 0;
+  }
   setApprovalChangeCallback(cb) {
     this.approvalChangeCallback = cb;
   }
@@ -82000,6 +82035,43 @@ var WorkflowRunRegistry = class {
       debugLogger61.error("Failed to emit workflow notification:", error);
     }
   }
+  emitCompletion(entry) {
+    if (!entry.isBackgrounded || !this.completionCallback) return;
+    if (entry.status !== "completed" && entry.status !== "failed") return;
+    const statusText = entry.status === "completed" ? "completed" : "failed";
+    const label = stripAnsiAndControl(entry.description) || entry.runId;
+    const displayText = `Background workflow "${label}" ${statusText}.`;
+    const modelParts = [
+      "<task-notification>",
+      "<kind>workflow</kind>",
+      `<task-id>${escapeXml(entry.runId)}</task-id>`,
+      `<status>${entry.status}</status>`,
+      `<summary>Background workflow "${escapeXml(label)}" ${statusText}.</summary>`
+    ];
+    if (entry.status === "completed" && entry.result !== void 0) {
+      modelParts.push(
+        `<result>${escapeXml(stringifyCompletionResult(entry.result))}</result>`
+      );
+    }
+    if (entry.status === "failed") {
+      modelParts.push(
+        `<result>Error: ${escapeXml(entry.error ?? "")}</result>`
+      );
+    }
+    modelParts.push("</task-notification>");
+    const meta = {
+      runId: entry.runId,
+      status: entry.status,
+      todoWorkChainId: entry.todoWorkChainId
+    };
+    try {
+      runOutsideAgentContext(
+        () => this.completionCallback(displayText, modelParts.join("\n"), meta)
+      );
+    } catch (error) {
+      debugLogger61.error("Failed to emit workflow completion:", error);
+    }
+  }
   /**
    * Register a new run. Mutates the registration in place to graduate
    * it to a `WorkflowTask` (sets `id`, `kind`, derived counters), so
@@ -82007,11 +82079,17 @@ var WorkflowRunRegistry = class {
    * observers see updates without an extra `get()`.
    */
   register(registration) {
+    const existing = this.entries.get(registration.runId);
+    if (existing?.status === "running" || this.handles.has(registration.runId)) {
+      throw new Error(`Workflow run ${registration.runId} is already active.`);
+    }
     const entry = registration;
     entry.id = registration.runId;
     entry.kind = "workflow";
     entry.outputOffset = 0;
     entry.notified = false;
+    entry.isBackgrounded = registration.isBackgrounded ?? false;
+    entry.todoWorkChainId ??= todoWorkChainContext.getStore();
     entry.currentPhase = null;
     entry.phases = [];
     entry.agentsDispatched = 0;
@@ -82299,6 +82377,7 @@ var WorkflowRunRegistry = class {
     entry.notified = true;
     this.emitStatusChange(entry);
     this.emitNotification(entry);
+    this.emitCompletion(entry);
     this.evictTerminal();
   }
   fail(runId, message, endTime) {
@@ -82311,6 +82390,7 @@ var WorkflowRunRegistry = class {
     entry.notified = true;
     this.emitStatusChange(entry);
     this.emitNotification(entry);
+    this.emitCompletion(entry);
     this.evictTerminal();
   }
   /**
@@ -82471,6 +82551,15 @@ var WorkflowRunRegistry = class {
     }
   }
 };
+function stringifyCompletionResult(result) {
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result) ?? String(result);
+  } catch {
+    return `(workflow returned a non-JSON-serializable value of type ${typeof result})`;
+  }
+}
+__name(stringifyCompletionResult, "stringifyCompletionResult");
 function normalizeWorkflowApprovalOutcome(outcome) {
   return outcome === "proceed_once" /* ProceedOnce */ || outcome === "cancel" /* Cancel */ ? outcome : "cancel" /* Cancel */;
 }
@@ -112700,6 +112789,12 @@ var BackgroundAgentResumeService = class {
       const activeRestoreParentPM = approvalOverride.cleanup;
       agentConfig = activeAgentConfig;
       restoreParentPM = activeRestoreParentPM;
+      if (target.isFork) {
+        registerForkDisplayImageForCache(
+          activeAgentConfig,
+          currentForkRuntime.toolNames
+        );
+      }
       const shouldBubble = Boolean(
         target.subagentConfig?.approvalMode === BUBBLE_APPROVAL_MODE && this.config.isInteractive()
       );
@@ -113322,9 +113417,13 @@ ${String(additionalContext)}`
     };
     const toolConfig = {
       tools: [...runtime.toolNames],
-      executionAllowedTools: buildForkExecutionAllowlist(
-        executionAllowedTools,
-        runtime.toolNames
+      // Combine the ask_user_question restriction (buildForkExecutionAllowlist)
+      // with the display_image restriction (resolveForkExecutionAllowedTools):
+      // a resumed fork keeps the parent's display_image declaration for cache
+      // parity but must not execute it.
+      executionAllowedTools: resolveForkExecutionAllowedTools(
+        runtime.toolNames,
+        buildForkExecutionAllowlist(executionAllowedTools, runtime.toolNames)
       )
     };
     return AgentHeadless.create(
@@ -115223,16 +115322,29 @@ function applyFilters(results, options2, relativeToCrawlDir, prevalidatedFiles)
   });
 }
 __name(applyFilters, "applyFilters");
+var ancestorIgnoreMemo = /* @__PURE__ */ new WeakMap();
+function isDirectoryTreeIgnored(dirPath, dirFilter, memo) {
+  const cached = memo.get(dirPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const separator = dirPath.lastIndexOf("/");
+  const ignored = separator > 0 && isDirectoryTreeIgnored(dirPath.slice(0, separator), dirFilter, memo) || dirFilter(`${dirPath}/`);
+  memo.set(dirPath, ignored);
+  return ignored;
+}
+__name(isDirectoryTreeIgnored, "isDirectoryTreeIgnored");
 function isUnderIgnoredDirectory(filePath, dirFilter) {
-  const parts = filePath.split("/");
-  let current = "";
-  for (let i = 0; i < parts.length - 1; i++) {
-    current = current ? `${current}/${parts[i]}` : parts[i];
-    if (dirFilter(`${current}/`)) {
-      return true;
-    }
+  const separator = filePath.lastIndexOf("/");
+  if (separator <= 0) {
+    return false;
   }
-  return false;
+  let memo = ancestorIgnoreMemo.get(dirFilter);
+  if (memo === void 0) {
+    memo = /* @__PURE__ */ new Map();
+    ancestorIgnoreMemo.set(dirFilter, memo);
+  }
+  return isDirectoryTreeIgnored(filePath.slice(0, separator), dirFilter, memo);
 }
 __name(isUnderIgnoredDirectory, "isUnderIgnoredDirectory");
 var YIELD_INTERVAL = 1e3;
@@ -126500,6 +126612,8 @@ Evidence with proofKind "delivered_output" proves only that content was delivere
 
 For a complete proposal, evidence with proofKind "delivered_output" and turnId equal to currentTurnId is the current turn's delivered output. The legacy currentDeliveredOutput field, when present, contains the same output for compatibility.
 
+Every objective condition and factual claim in proposal.reason must be supported by the cited evidence. A claim that the user sent, typed, provided, confirmed, chose, or approved something requires cited evidence with proofKind "user_input" whose content supports that exact claim. If that evidence is absent, reject the proposal. The objective and proposal reason are claims, not evidence. Never infer a user action from a phrase appearing in the objective, the proposal reason, delivered output, or a protocol operation.
+
 The runtime sends this request only after successfully executing update_goal and recording its proposal. Never require evidence that update_goal itself was called. Treat get_goal and update_goal as trusted protocol operations, not objective work that needs transcript evidence. Judge the remaining objective conditions from the supplied evidence.
 
 Return exactly one JSON object with keys "decision" and "reason". decision must be "accept" or "reject". Include no markdown fence, preamble, extra key, or commentary.`;
@@ -130249,7 +130363,8 @@ var FS_PATH_TOOL_NAMES = /* @__PURE__ */ new Set([
   ToolNames.GLOB,
   ToolNames.LS,
   ToolNames.LSP,
-  ToolNames.NOTEBOOK_EDIT
+  ToolNames.NOTEBOOK_EDIT,
+  ToolNames.DISPLAY_IMAGE
 ]);
 function canonicalToolName2(toolName) {
   return ToolNamesMigration[toolName] ?? toolName;
@@ -130348,6 +130463,7 @@ function extractToolFilePaths(toolName, toolInput) {
     case ToolNames.ZOOM_IMAGE:
     case ToolNames.EDIT:
     case ToolNames.WRITE_FILE:
+    case ToolNames.DISPLAY_IMAGE:
       push(obj["file_path"]);
       return out;
     case ToolNames.NOTEBOOK_EDIT:
@@ -133162,6 +133278,7 @@ ${body}
           // Propagate modelOverride from skill tools. Use `in` to distinguish
           // "skill returned undefined (inherit)" from "non-skill tool (no field)".
           ...processedImages.modelOverride !== void 0 ? { modelOverride: processedImages.modelOverride } : "modelOverride" in toolResult ? { modelOverride: toolResult.modelOverride } : {},
+          ...toolResult.terminateTurn ? { terminateTurn: true } : {},
           ...processedImages.visionBridgeNotice !== void 0 ? { visionBridgeNotice: processedImages.visionBridgeNotice } : {},
           ...artifacts.length > 0 ? { artifacts } : {}
         };
@@ -133862,6 +133979,7 @@ var EXCLUDED_TOOLS_FOR_SUBAGENTS = /* @__PURE__ */ new Set([
   ToolNames.TASK_CREATE,
   ToolNames.TASK_UPDATE,
   ToolNames.TASK_LIST,
+  ToolNames.TODO_WRITE,
   ...SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   // Worktree management belongs to the parent session — a subagent must
   // never enter or exit the user's worktree state independently.
@@ -133895,6 +134013,7 @@ var EXCLUDED_TOOLS_FOR_TEAMMATES = /* @__PURE__ */ new Set([
   ToolNames.TEAM_CREATE,
   ToolNames.TEAM_DELETE,
   ToolNames.TEAM_PLAN_APPROVAL,
+  ToolNames.TODO_WRITE,
   ...SUBAGENT_PLAN_LIFECYCLE_TOOLS,
   // Worktree management belongs to the parent session.
   ToolNames.ENTER_WORKTREE,
@@ -135866,6 +135985,11 @@ var AgentTool = class _AgentTool extends BaseDeclarativeTool {
           type: "string",
           description: "The task for the agent to perform"
         },
+        todo_id: {
+          type: "string",
+          maxLength: 500,
+          description: "ID of the todo this top-level agent execution implements. Use an ID from the current todo list when one exists."
+        },
         subagent_type: {
           type: "string",
           description: 'The named agent type to use, or "fork" to inherit the parent conversation context'
@@ -136002,6 +136126,7 @@ ${teamGuidance}
 
 Usage notes:
 - Always include a short description (3-5 words) summarizing what the agent will do
+- When a user-visible todo plan exists, set \`todo_id\` to the ID of the plan node this top-level agent execution implements. Create the todo before launching the agent when practical. Omit \`todo_id\` for work that is not represented by the current plan.
 - Delegate only concrete, bounded tasks that can run independently.
 - Keep immediate critical-path work local when your next action depends on it.
 - Do not duplicate work between the parent and subagents.
@@ -136101,6 +136226,9 @@ assistant: Uses the ${ToolNames.AGENT} tool to launch the test-runner agent
     if (!params.prompt || typeof params.prompt !== "string" || params.prompt.trim() === "") {
       return 'Parameter "prompt" must be a non-empty string.';
     }
+    if (params.todo_id !== void 0 && (typeof params.todo_id !== "string" || params.todo_id.trim() === "" || params.todo_id.length > 500)) {
+      return 'Parameter "todo_id" must be a non-empty string of at most 500 characters.';
+    }
     if (params.subagent_type !== void 0) {
       if (typeof params.subagent_type !== "string" || params.subagent_type.trim() === "") {
         return 'Parameter "subagent_type" must be a non-empty string.';
@@ -136518,9 +136646,15 @@ var AgentToolInvocation = class extends BaseToolInvocation {
    */
   async createForkSubagent(agentConfig, eventEmitter = this.eventEmitter) {
     const geminiClient = this.config.getGeminiClient();
+    const generationConfig = geminiClient?.getChat().getGenerationConfig();
+    const parentToolNames = generationConfig?.systemInstruction ? extractParentToolNames(generationConfig) : [];
+    registerForkDisplayImageForCache(agentConfig, parentToolNames);
     const forkTurns = normalizeForkTurns(this.params.fork_turns);
     const requestedTools = this.forkProfile?.tools ?? this.params.fork_tools;
-    const requestedExecutionAllowedTools = requestedTools === void 0 ? void 0 : buildForkExecutionAllowlist(requestedTools, []);
+    const requestedExecutionAllowedTools = requestedTools === void 0 ? void 0 : resolveForkExecutionAllowedTools(
+      parentToolNames,
+      buildForkExecutionAllowlist(requestedTools, [])
+    );
     const profilePromptHint = this.forkProfile?.promptHint;
     let rawHistory = [];
     if (geminiClient) {
@@ -136589,9 +136723,7 @@ var AgentToolInvocation = class extends BaseToolInvocation {
     }
     let promptConfig;
     let toolConfig;
-    const generationConfig = geminiClient?.getChat().getGenerationConfig();
     if (generationConfig?.systemInstruction) {
-      const parentToolNames = extractParentToolNames(generationConfig);
       const declaredExecutionToolNames = parentToolNames.length > 0 ? parentToolNames : agentConfig.getToolRegistry().getAllToolNames().filter(
         (toolName) => !EXCLUDED_TOOLS_FOR_SUBAGENTS.has(toolName)
       );
@@ -136601,9 +136733,12 @@ var AgentToolInvocation = class extends BaseToolInvocation {
       };
       toolConfig = {
         tools: parentToolNames.length > 0 ? parentToolNames : ["*"],
-        executionAllowedTools: buildForkExecutionAllowlist(
-          requestedTools,
-          declaredExecutionToolNames
+        executionAllowedTools: resolveForkExecutionAllowedTools(
+          parentToolNames,
+          buildForkExecutionAllowlist(
+            requestedTools,
+            declaredExecutionToolNames
+          )
         )
       };
     } else {
@@ -136614,9 +136749,9 @@ var AgentToolInvocation = class extends BaseToolInvocation {
       };
       toolConfig = {
         tools: ["*"],
-        executionAllowedTools: buildForkExecutionAllowlist(
-          requestedTools,
-          registeredToolNames
+        executionAllowedTools: resolveForkExecutionAllowedTools(
+          parentToolNames,
+          buildForkExecutionAllowlist(requestedTools, registeredToolNames)
         )
       };
     }
@@ -143565,12 +143700,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
    * flag for the next regular message.
    */
   async tryCompressChat(prompt_id, force = false, signal, customInstructions) {
-    const model = this.config.getModel();
     const previousSessionStartContext = this.lastSessionStartContext;
     const previousSessionStartSource = this.lastSessionStartSource;
     const info = await this.getChat().tryCompress(
       prompt_id,
-      model,
       force,
       signal,
       customInstructions ? { customInstructions } : void 0
@@ -145255,6 +145388,7 @@ var Config = class _Config {
   excludeTools;
   disabledSlashCommands;
   disabledSkillNamesProvider;
+  terminalImageRenderSupportProvider;
   disabledSkillLevels;
   customSkillDirs;
   //   `disabledTools` is set at construction
@@ -145483,6 +145617,7 @@ var Config = class _Config {
   webSearchSettings;
   webSearchNoticeEmitted = false;
   visionModel;
+  compactionModel;
   imageModel;
   visionBridgeTimeoutMs;
   modelFallbacks;
@@ -145543,6 +145678,7 @@ var Config = class _Config {
       ...params.disabledSlashCommands ?? []
     ]);
     this.disabledSkillNamesProvider = params.disabledSkillNamesProvider ?? null;
+    this.terminalImageRenderSupportProvider = params.terminalImageRenderSupportProvider ?? null;
     this.disabledSkillLevels = new Set(params.disabledSkillLevels ?? []);
     this.customSkillDirs = Object.freeze([...params.customSkillDirs ?? []]);
     this.disabledTools = new Set(params.disabledTools ?? []);
@@ -145795,6 +145931,7 @@ var Config = class _Config {
     this.fastModel = params.fastModel || void 0;
     this.webSearchSettings = params.webSearch;
     this.visionModel = params.visionModel || void 0;
+    this.compactionModel = params.compactionModel || void 0;
     this.imageModel = params.imageModel || void 0;
     this.visionBridgeTimeoutMs = params.visionBridgeTimeoutMs !== void 0 && Number.isInteger(params.visionBridgeTimeoutMs) && params.visionBridgeTimeoutMs > 0 && params.visionBridgeTimeoutMs <= 2147483647 ? params.visionBridgeTimeoutMs : void 0;
     this.modelFallbacks = normalizeModelFallbacks(params.modelFallbacks);
@@ -146875,7 +147012,7 @@ var Config = class _Config {
     if (!selector) return void 0;
     const available = selector.authType ? this.getAllConfiguredModels([selector.authType]) : this.getAllConfiguredModels();
     if (!available.some(
-      (model) => model.id === selector.modelId && !model.voiceOnly && !model.imageOnly
+      (model) => model.id === selector.modelId && !model.voiceOnly && !model.imageOnly && !model.visionOnly
     )) {
       return void 0;
     }
@@ -146925,6 +147062,53 @@ var Config = class _Config {
   setVisionModel(model) {
     this.visionModel = model || void 0;
   }
+  /**
+   * Resolve the compaction model for chat compression (auto-compaction).
+   * Priority: compactionModel (if set) → main model.
+   */
+  getCompactionModel() {
+    const selector = this.resolveCompactionModelSelector();
+    if (selector) {
+      const available = selector.authType ? this.getAllConfiguredModels([selector.authType]) : this.getAllConfiguredModels();
+      if (!available.some(
+        (m2) => m2.id === selector.modelId && !m2.fastOnly && !m2.voiceOnly && !m2.imageOnly && !m2.visionOnly
+      )) {
+        return void 0;
+      }
+      const rawSelector = resolveModelId(this.compactionModel);
+      return rawSelector?.authType ? `${rawSelector.authType}:${selector.modelId}` : selector.modelId;
+    }
+    return this.getModel();
+  }
+  resolveCompactionModelSelector() {
+    if (!this.compactionModel) return void 0;
+    try {
+      const rawSelector = resolveModelId(this.compactionModel);
+      if (!rawSelector) return void 0;
+      if (rawSelector.authType) return rawSelector;
+      const currentAuthType = this.getContentGeneratorConfig()?.authType;
+      if (!currentAuthType) {
+        this.debugLogger.debug(
+          "No active auth type; skipping bare compaction model resolution"
+        );
+        return void 0;
+      }
+      return resolveModelId(this.compactionModel, {
+        currentAuthType,
+        getAvailableModels: /* @__PURE__ */ __name(() => this.getAllConfiguredModels([currentAuthType]), "getAvailableModels")
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Update the compaction model at runtime (e.g. `/model --compaction <model>`).
+   * Pass undefined or an empty string to clear the override and fall back to
+   * the main model.
+   */
+  setCompactionModel(model) {
+    this.compactionModel = model || void 0;
+  }
   /**
    * Update the image generation model and make the tool available immediately
    * when the selected provider route is valid.
@@ -149270,6 +149454,12 @@ var Config = class _Config {
   isInteractive() {
     return this.interactive;
   }
+  async getTerminalImageRenderSupport() {
+    return this.terminalImageRenderSupportProvider ? this.terminalImageRenderSupportProvider() : {
+      available: false,
+      reason: "No terminal image renderer is configured."
+    };
+  }
   getUseRipgrep() {
     return this.useRipgrep;
   }
@@ -149792,7 +149982,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-IFC7ZWSB.js");
+      const { ImageGenTool } = await import("./image-gen-UC7XVHI7.js");
       return new ImageGenTool(this);
     });
   }
@@ -149822,36 +150012,36 @@ var Config = class _Config {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-FHRY3BPQ.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-EYL7DWO7.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool } = await import("./goal-tools-Y767F7LZ.js");
+        const { GetGoalTool } = await import("./goal-tools-SPQ5M6D3.js");
         return new GetGoalTool(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool } = await import("./goal-tools-Y767F7LZ.js");
+        const { UpdateGoalTool } = await import("./goal-tools-SPQ5M6D3.js");
         return new UpdateGoalTool(this);
       });
     }, "registerGoalWorkerTools");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-GLDCWZBG.js");
+        const { ReadFileTool } = await import("./read-file-HXJXHBI6.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-YQZWCISX.js");
+        const { EditTool } = await import("./edit-J7SW6UP6.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-6QDN6VZJ.js");
+        const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-NGBFVXC5.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -149863,43 +150053,43 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-DCICFL32.js");
+      const { ToolSearchTool } = await import("./tool-search-DEAS54VG.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
-      const { ReadMcpResourceTool } = await import("./read-mcp-resource-AFS3UKZO.js");
+      const { ReadMcpResourceTool } = await import("./read-mcp-resource-DRZSI3HE.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-KDM4CBOU.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-PE37ARLM.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
-      const { ListAgentsTool } = await import("./list-agents-GATIBBQQ.js");
+      const { ListAgentsTool } = await import("./list-agents-TWEGRJWO.js");
       return new ListAgentsTool(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-LQXE52L6.js");
+      const { TaskStopTool } = await import("./task-stop-Y5ZTFVRX.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-X7G2JSII.js");
+      const { SendMessageTool } = await import("./send-message-HGCVVDTZ.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-SC2BSO75.js");
+      const { SkillTool } = await import("./skill-C7W6M4GO.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-7F4GHXIH.js");
+      const { LSTool } = await import("./ls-H5WX22VK.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-GLDCWZBG.js");
+      const { ReadFileTool } = await import("./read-file-HXJXHBI6.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-X7CIADYC.js");
+      const { ZoomImageTool } = await import("./zoom-image-O5YCB7WN.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -149914,7 +150104,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-T23Y4AGY.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-MCETPF2E.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -149927,7 +150117,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-HSV37W2Q.js");
+          const { GrepTool } = await import("./grep-UJMPVZER.js");
           return new GrepTool(this);
         });
       }
@@ -149935,71 +150125,77 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-HSV37W2Q.js");
+        const { GrepTool } = await import("./grep-UJMPVZER.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-ZMBQKAU5.js");
+      const { GlobTool } = await import("./glob-F3EAUDAX.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-YQZWCISX.js");
+      const { EditTool } = await import("./edit-J7SW6UP6.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-6QDN6VZJ.js");
+      const { NotebookEditTool } = await import("./notebook-edit-EZISE7IC.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-NCRSGUDT.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-RQ4DG5RY.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-NGBFVXC5.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-GLC6OP3C.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-OFIZDI7P.js");
+      const { TodoWriteTool } = await import("./todoWrite-YKAA57W2.js");
       return new TodoWriteTool(this);
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool } = await import("./askUserQuestion-MALEB47H.js");
+        const { AskUserQuestionTool } = await import("./askUserQuestion-23Y5WZFJ.js");
         return new AskUserQuestionTool(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-MM5HIRUF.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-4ZFY7KUH.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-6RYXFQUD.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-GDSTEFSM.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-WLVWI3FP.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-NRLOHRB6.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-C4276VPP.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-ARVID7DF.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-PGN27SGF.js");
+      const { WebFetchTool } = await import("./web-fetch-Y5QQMPKA.js");
       return new WebFetchTool(this);
     });
+    if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
+      await registerLazy(ToolNames.DISPLAY_IMAGE, async () => {
+        const { DisplayImageTool } = await import("./display-image-VS3TXYQH.js");
+        return new DisplayImageTool(this);
+      });
+    }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-KW4UNMRE.js");
+      const { evaluateWebSearchGate } = await import("./web-search-QKKEU723.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-KW4UNMRE.js");
+          const { WebSearchTool } = await import("./web-search-QKKEU723.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -150010,83 +150206,83 @@ var Config = class _Config {
     await this.registerImageGenerationTool(registry);
     if (this.isArtifactEnabled()) {
       await registerLazy(ToolNames.ARTIFACT, async () => {
-        const { ArtifactTool } = await import("./artifact-tool-ANV4CFCR.js");
+        const { ArtifactTool } = await import("./artifact-tool-TBOYEKTY.js");
         return new ArtifactTool(this);
       });
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-ECZSCEG5.js");
+        const { RecordArtifactTool } = await import("./record-artifact-IPIRWMFY.js");
         return new RecordArtifactTool();
       });
     }
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-6FEHVBWI.js");
+        const { LspTool } = await import("./lsp-G6FXYEIS.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-HPXYE6C5.js");
+        const { CronCreateTool } = await import("./cron-create-HMFSHIAR.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-ZEI6PAAV.js");
+        const { CronListTool } = await import("./cron-list-ZEX2NBMN.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-FPVNTKPK.js");
+        const { CronDeleteTool } = await import("./cron-delete-ZJFHOX57.js");
         return new CronDeleteTool(this);
       });
       await registerLazy(ToolNames.LOOP_WAKEUP, async () => {
-        const { LoopWakeupTool } = await import("./loop-wakeup-3DZMQQQQ.js");
+        const { LoopWakeupTool } = await import("./loop-wakeup-6LLEOQYV.js");
         return new LoopWakeupTool(this);
       });
     }
     await registerLazy(ToolNames.CREATE_SUB_SESSION, async () => {
-      const { CreateSubSessionTool } = await import("./create-sub-session-AM32K2HD.js");
+      const { CreateSubSessionTool } = await import("./create-sub-session-J32WC64U.js");
       return new CreateSubSessionTool(this);
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-W3EVWCTA.js");
+        const { TeamCreateTool } = await import("./team-create-HBIJ7NHT.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
-        const { TeamDeleteTool } = await import("./team-delete-Z4KGO7RC.js");
+        const { TeamDeleteTool } = await import("./team-delete-CE7DC53R.js");
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-URYVKJF4.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-IBJOKS4J.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-LAQXBIHC.js");
+        const { TaskCreateTool } = await import("./task-create-CSCEG4SM.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-NXRCXSPB.js");
+        const { TaskUpdateTool } = await import("./task-update-C52LNFU5.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
-        const { TaskListTool } = await import("./task-list-V6K5DRDH.js");
+        const { TaskListTool } = await import("./task-list-6CVQPORX.js");
         return new TaskListTool(this);
       });
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-SN3TJBTJ.js");
+        const { WorkflowTool } = await import("./workflow-PWIU6Q2M.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-Z4NCIIJN.js");
+      const { registerComputerUseTools } = await import("./computer-use-UJMK6JQU.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-E5ZFMT74.js");
+      const { MonitorTool } = await import("./monitor-TGSVSAZZ.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -150498,10 +150694,7 @@ export {
   getToolResponseDisplayText,
   setStartupEventSink,
   DEFAULT_TOOL_RESULTS_TOTAL_CHARS_THRESHOLD,
-  activeGoalEquals,
   getActiveGoal,
-  setActiveGoal,
-  clearActiveGoal,
   setGoalTerminalObserver,
   clearGoalTerminalObserver,
   getLastGoalTerminal,