@qwen-code/qwen-code 0.21.10 → 0.21.11

package/chunks/{acpAgent-AGS6HLQQ.js → acpAgent-43JURWOW.js}

@@ -13,17 +13,17 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-NDU63YLI.js";
+} from "./chunk-ESVSQKPY.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-MIKXJYZB.js";
+} from "./chunk-MCHGE3EC.js";
 import {
   recomputeMcpGating
-} from "./chunk-4MKXUHXY.js";
+} from "./chunk-SUTP6CZA.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -31,40 +31,43 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-7GTMV7UE.js";
+} from "./chunk-TTB6GBJ6.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-QG3FFJYU.js";
+} from "./chunk-AAOONL5N.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-YWPSGJFI.js";
+} from "./chunk-DSKLWQHC.js";
 import "./chunk-NYX53SV4.js";
-import "./chunk-NV3F44FL.js";
+import "./chunk-TNQLAI6I.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-F6WDTQ3M.js";
+} from "./chunk-TNS2M7VL.js";
 import "./chunk-4WGODMVR.js";
 import {
   startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-KZ22NXBY.js";
+} from "./chunk-QGZN4RYB.js";
 import "./chunk-KW7NOTN6.js";
-import "./chunk-CTJLZLB5.js";
-import "./chunk-IRZ2ZH72.js";
-import "./chunk-URKIBIFC.js";
+import "./chunk-EN2J77G7.js";
+import "./chunk-4EX3DBFH.js";
+import {
+  isGoalStatusKind
+} from "./chunk-EKTCKZV5.js";
+import "./chunk-45HPDU3F.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
-import "./chunk-YF5MALI4.js";
+import "./chunk-G64M7R2Y.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
-} from "./chunk-JT7XS4YW.js";
-import "./chunk-DCZEPFB4.js";
+} from "./chunk-M2NMFAFR.js";
+import "./chunk-NM3E6GGL.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
@@ -86,25 +89,21 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-6LP743KE.js";
+} from "./chunk-2R2HYSUQ.js";
 import {
+  BaseEmitter,
   HistoryReplayer,
-  MessageEmitter,
   PlanEmitter,
   ToolCallEmitter,
-  collectGoalStatusItemsFromRecords,
-  goalTerminalEventToHistoryItem,
-  recordGoalStatusItem,
-  restoreGoalFromHistory
-} from "./chunk-5MZCSWI4.js";
-import "./chunk-OWMAZHIX.js";
-import "./chunk-ZRBMO3C7.js";
+  createTranscriptMessageUpdate,
+  createTranscriptUsageUpdate,
+  hasFullSessionContext
+} from "./chunk-W2ITCESM.js";
+import "./chunk-47FQVRCO.js";
+import "./chunk-HMCSRTDY.js";
 import "./chunk-4NFY2S7N.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
-import {
-  isTerminalGoalStatusKind
-} from "./chunk-EKTCKZV5.js";
 import "./chunk-3Z43GZUQ.js";
 import {
   buildToolWriteOriginMeta
@@ -120,18 +119,18 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-Y3OVRWRY.js";
+} from "./chunk-DM4C3OX5.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-LLCWZQCU.js";
+} from "./chunk-HZV75ET2.js";
 import {
   readVoiceModel
-} from "./chunk-EBZ6BJTF.js";
-import "./chunk-AOHJKPKL.js";
+} from "./chunk-F4T5J34H.js";
+import "./chunk-IQFYO5BF.js";
 import "./chunk-NTTBXH7U.js";
-import "./chunk-VSFKIRRW.js";
+import "./chunk-AKLY5M2C.js";
 import "./chunk-3SH53ANB.js";
 import {
   ACP_ROUTE_ID_PREFIX,
@@ -141,32 +140,32 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-2PLNY5TN.js";
+} from "./chunk-23GFHEM3.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-BGXZBI5B.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-NEOXOWYH.js";
-import "./chunk-UMD7WQTR.js";
+import "./chunk-U7QUDFPD.js";
+import "./chunk-N3ZWGKXN.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-LHEC5V6G.js";
-import "./chunk-67EWJE77.js";
-import "./chunk-E2FPSSKP.js";
+import "./chunk-VRWOMUZM.js";
+import "./chunk-ENEEQMGM.js";
+import "./chunk-JPA7IDTE.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-4WL6SY4F.js";
+} from "./chunk-X5GLCWPX.js";
 import {
   SESSION_SOURCE_META_KEY,
   parseSessionSource
-} from "./chunk-F24A2JBM.js";
+} from "./chunk-2AAFGCWP.js";
 import "./chunk-MZSJ43WV.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
 import {
   ndJsonStream
-} from "./chunk-I5VM3SKY.js";
+} from "./chunk-TKAEODJR.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -174,8 +173,8 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-DA4HRSBW.js";
-import "./chunk-VKJ4KTPJ.js";
+} from "./chunk-OPBATTFQ.js";
+import "./chunk-3GCU5O2E.js";
 import "./chunk-V6WHFGST.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
@@ -188,6 +187,7 @@ import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
   DAEMON_MODEL_PROMPT_META_KEY,
+  DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
@@ -202,7 +202,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-W5UC37EE.js";
+} from "./chunk-HHGQGTJQ.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError
@@ -210,7 +210,7 @@ import {
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-YP5KH5Y7.js";
-import "./chunk-PBRVUF5B.js";
+import "./chunk-K7JW6V5O.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-HIBNSEJE.js";
 import "./chunk-M5GB774H.js";
@@ -221,20 +221,20 @@ import {
   PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
   isValidExternalToolGuardDenialReason
 } from "./chunk-BKHCW2BI.js";
-import "./chunk-UVX4Y6IN.js";
+import "./chunk-AQHNAA7E.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-DX3RGJMS.js";
+} from "./chunk-LT532KF4.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
-} from "./chunk-UDXSXLER.js";
+} from "./chunk-IW6RQPQB.js";
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-KID7K6H2.js";
+} from "./chunk-JOXXPM3X.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -243,8 +243,8 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-ABVRJU3D.js";
-import "./chunk-UBX6NL47.js";
+} from "./chunk-4PFKN7CQ.js";
+import "./chunk-T4576UW4.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -254,7 +254,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-UEOKWYGY.js";
+} from "./chunk-KFCTC5IJ.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -262,18 +262,18 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-ZJ4W6SUY.js";
+} from "./chunk-UM57UTTV.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD
-} from "./chunk-VFMASYQA.js";
-import "./chunk-Q3AL4JQ3.js";
-import "./chunk-AEL7KN2O.js";
+} from "./chunk-MS7GNABG.js";
+import "./chunk-LA3FF7RO.js";
+import "./chunk-EOBM4T2Z.js";
 import "./chunk-VJNBRRZG.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-GWVUR3QZ.js";
+} from "./chunk-YIKMBYMT.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import "./chunk-XFSFZCM5.js";
@@ -326,7 +326,6 @@ import {
   buildPermissionCheckContext,
   buildSessionRecoveryPlanFromApiHistory,
   clampInlineMediaPart,
-  clearGoalTerminalObserver,
   computeUniqueBranchTitle,
   convertToFunctionErrorResponse,
   convertToFunctionResponse,
@@ -384,6 +383,7 @@ import {
   normalizeEventPayload,
   normalizeSnapshotPayload,
   persistPermissionOutcome,
+  projectGoalStateToLegacy,
   readManyFiles,
   recordAllow,
   recordFallbackApprove,
@@ -396,7 +396,6 @@ import {
   runManagedAutoMemoryDream,
   runManagedRememberByAgent,
   sessionIdContext,
-  setGoalTerminalObserver,
   shouldClassifyAllShellForAutoMode,
   shouldFallback,
   shouldFirePermissionDeniedForAutoMode,
@@ -404,29 +403,29 @@ import {
   shouldHaltOnTurnToolCallCap,
   shouldRunAutoModeForCall,
   subagentGenerator,
-  unregisterGoalHook,
+  truncateNotificationLabel,
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-EI3NWELG.js";
+} from "./chunk-UIZGNLBP.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import {
   external_exports
-} from "./chunk-H6XPXXMH.js";
-import "./chunk-2UUMVNYT.js";
-import "./chunk-MVUQRLOH.js";
-import "./chunk-XCWO3SMQ.js";
-import "./chunk-7MH4J33A.js";
+} from "./chunk-CQ35AJ4Z.js";
+import "./chunk-QTI7SRXI.js";
+import "./chunk-KT4OWAAZ.js";
+import "./chunk-IX7CFQGA.js";
+import "./chunk-N7NBMAMW.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-TRRF5BSP.js";
+import "./chunk-XT6TGJFD.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-GNPNYXJB.js";
-import "./chunk-HUWENAHO.js";
+import "./chunk-XLQS3VI6.js";
+import "./chunk-NWPO6I7V.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -434,21 +433,24 @@ import {
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-J6SZID63.js";
+import "./chunk-2AZMF6G5.js";
 import "./chunk-KRXPRVGL.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-GM463R2B.js";
-import "./chunk-SEZ556DZ.js";
-import "./chunk-2FRY5CRX.js";
+} from "./chunk-GZGDJ4E6.js";
+import "./chunk-T6W4KACQ.js";
+import "./chunk-MWZYNOCG.js";
 import {
+  GoalPersistenceUnavailableError,
+  emptyGoalSnapshot,
+  goalTurnContext,
   wrapUserPromptSubmitContext
-} from "./chunk-QUI267ZP.js";
+} from "./chunk-SAQHDAUJ.js";
 import {
   APPROVAL_MODES
-} from "./chunk-WAUGQKUU.js";
-import "./chunk-DZUO626D.js";
+} from "./chunk-6LYDH7VT.js";
+import "./chunk-2XZWO53E.js";
 import {
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
@@ -456,31 +458,32 @@ import {
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor,
   withDaemonSpan
-} from "./chunk-4TRQPFDP.js";
+} from "./chunk-BJKREW56.js";
 import "./chunk-SAH4BD2J.js";
+import "./chunk-25OFRBH2.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-CPG6P4GG.js";
+} from "./chunk-EYS3GGM3.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-2J3OJGTL.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent
-} from "./chunk-IA7TGCN2.js";
+} from "./chunk-ZV4XVYL3.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-EQL65XGA.js";
+import "./chunk-V3LXMASR.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-3P2LV43B.js";
+} from "./chunk-KCCODSAA.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-HV76SFIA.js";
-import "./chunk-4PYCZH2V.js";
+import "./chunk-5HBFERG5.js";
+import "./chunk-EYW54TBD.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-SR7RZ4MS.js";
-import "./chunk-M6HMMKVG.js";
+import "./chunk-O4BBDP2G.js";
+import "./chunk-KPVVWKF3.js";
 import {
   REASONING_EFFORT_TIERS,
   applyReasoningEffort
@@ -491,7 +494,7 @@ import {
   getToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-EI3HZX6C.js";
+import "./chunk-GJJQV4PY.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -502,6 +505,7 @@ import {
   PromptSuggestionEvent,
   RepeatedToolFailureGuardEvent,
   UserPromptEvent,
+  apiActivityTracker,
   formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
@@ -523,17 +527,17 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-YGT2AUJ7.js";
-import "./chunk-WOJZWRAZ.js";
+} from "./chunk-U2JLICUY.js";
+import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-FVKHVJZQ.js";
+} from "./chunk-732MOPEM.js";
 import {
   runSideQuery
-} from "./chunk-COBO5EBO.js";
-import "./chunk-6ZRFAKXK.js";
+} from "./chunk-CTQE2NB2.js";
+import "./chunk-IEP44U2R.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -541,20 +545,20 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-PYQADEFD.js";
+} from "./chunk-XTH2OMDS.js";
 import {
   AuthType,
   preloadContentGenerator
-} from "./chunk-Y4R47ZUH.js";
+} from "./chunk-MDQSCFAZ.js";
 import "./chunk-F6WFNA7U.js";
 import "./chunk-46UV252V.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-ZBVS26BY.js";
-import "./chunk-KKBPOU75.js";
-import "./chunk-EUNWC2VS.js";
-import "./chunk-FOGU3LJX.js";
+} from "./chunk-FPGTNKCP.js";
+import "./chunk-EFIMD5VA.js";
+import "./chunk-NC4O6UE6.js";
+import "./chunk-F6AOBFUN.js";
 import {
   endToolExecutionSpan,
   endToolSpan,
@@ -563,21 +567,21 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-L2AFWWJE.js";
-import "./chunk-W4RQUHY3.js";
-import "./chunk-PDPFQ2FO.js";
+} from "./chunk-HUE2M6VI.js";
+import "./chunk-HHJLM3WQ.js";
+import "./chunk-L2GTEEEU.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-OIVKILPI.js";
+} from "./chunk-MPBRV3UU.js";
 import "./chunk-VOQXFAY5.js";
-import "./chunk-AQAJJMRR.js";
+import "./chunk-3LHYTQ2R.js";
 import {
   runExitCleanup
-} from "./chunk-AAE6SR4Q.js";
+} from "./chunk-RUKNJEJO.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -1424,6 +1428,86 @@ function prefixMidTurnUserMessageParts(parts, displayText) {
 }
 __name(prefixMidTurnUserMessageParts, "prefixMidTurnUserMessageParts");
 
+// packages/cli/src/ui/utils/restoreGoal.ts
+init_esbuild_shims();
+function findGoalToRestore(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const item = history[i];
+    if (item?.type !== "goal_status" /* GOAL_STATUS */) continue;
+    const goal = item;
+    if (goal.kind !== "set" && goal.kind !== "checking") return null;
+    const setAt = goal.setAt ?? findSetAtOfRun(history, i);
+    return {
+      condition: goal.condition,
+      iterations: goal.iterations ?? 0,
+      ...setAt !== void 0 ? { setAt } : {}
+    };
+  }
+  return null;
+}
+__name(findGoalToRestore, "findGoalToRestore");
+function findSetAtOfRun(history, startIndex) {
+  const start = history[startIndex];
+  const condition = start?.condition;
+  for (let i = startIndex - 1; i >= 0; i--) {
+    const item = history[i];
+    if (item?.type !== "goal_status" /* GOAL_STATUS */) continue;
+    const goal = item;
+    if (goal.kind !== "set" && goal.kind !== "checking") return void 0;
+    if (goal.condition !== condition) return void 0;
+    if (goal.setAt !== void 0) return goal.setAt;
+  }
+  return void 0;
+}
+__name(findSetAtOfRun, "findSetAtOfRun");
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(finiteNumber, "finiteNumber");
+function isTranscriptItemRecord(item) {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+__name(isTranscriptItemRecord, "isTranscriptItemRecord");
+function parseGoalStatusItem(item) {
+  if (!isTranscriptItemRecord(item)) return null;
+  if (item["type"] !== "goal_status" /* GOAL_STATUS */) return null;
+  const kind = item["kind"];
+  const condition = item["condition"];
+  if (!isGoalStatusKind(kind) || typeof condition !== "string") return null;
+  const iterations = finiteNumber(item["iterations"]);
+  const setAt = finiteNumber(item["setAt"]);
+  const durationMs = finiteNumber(item["durationMs"]);
+  const lastReason = typeof item["lastReason"] === "string" ? item["lastReason"] : void 0;
+  return {
+    type: "goal_status" /* GOAL_STATUS */,
+    kind,
+    condition,
+    ...iterations !== void 0 ? { iterations } : {},
+    ...setAt !== void 0 ? { setAt } : {},
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...lastReason !== void 0 ? { lastReason } : {}
+  };
+}
+__name(parseGoalStatusItem, "parseGoalStatusItem");
+function collectGoalStatusItemsFromRecords(records) {
+  const items = [];
+  for (const record of records) {
+    if (record.type !== "system" || record.subtype !== "slash_command") {
+      continue;
+    }
+    const payload = record.systemPayload;
+    if (payload?.phase !== "result") continue;
+    const raws = payload.outputHistoryItems;
+    if (!Array.isArray(raws)) continue;
+    for (const raw of raws) {
+      const item = parseGoalStatusItem(raw);
+      if (item) items.push(item);
+    }
+  }
+  return items;
+}
+__name(collectGoalStatusItemsFromRecords, "collectGoalStatusItemsFromRecords");
+
 // packages/cli/src/acp-integration/session/tool-call-preparation-tracker.ts
 init_esbuild_shims();
 var ToolCallPreparationTracker = class {
@@ -1497,6 +1581,205 @@ var ToolCallPreparationTracker = class {
   }
 };
 
+// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+init_esbuild_shims();
+function buildGoalStatusUpdate(status) {
+  return {
+    sessionUpdate: "agent_message_chunk",
+    content: { type: "text", text: "" },
+    _meta: {
+      goalStatus: status
+    }
+  };
+}
+__name(buildGoalStatusUpdate, "buildGoalStatusUpdate");
+function buildGoalStateUpdate(snapshot, cause, previousGoal = null) {
+  const projection = cause ? projectGoalStateToLegacy({ v: 2, cause, snapshot }, previousGoal) : void 0;
+  const goalStatus = projection ? (() => {
+    const { type: _type, ...status } = projection.goalStatus;
+    return status;
+  })() : void 0;
+  return {
+    sessionUpdate: "agent_message_chunk",
+    content: { type: "text", text: "" },
+    _meta: {
+      goalState: snapshot,
+      ...goalStatus ? { goalStatus } : {},
+      ...projection?.goalTerminal ? { goalTerminal: projection.goalTerminal } : {}
+    }
+  };
+}
+__name(buildGoalStateUpdate, "buildGoalStateUpdate");
+var MessageEmitter = class extends BaseEmitter {
+  static {
+    __name(this, "MessageEmitter");
+  }
+  /**
+   * Emits a StopHookLoop event when Stop hooks create a loop.
+   * This informs the client that Stop hooks have been executed multiple times.
+   *
+   * @param iterationCount - The current iteration count
+   * @param reasons - Array of reasons from each Stop hook execution
+   * @param stopHookCount - Number of Stop hooks that were executed
+   */
+  async emitStopHookLoop(iterationCount, reasons, stopHookCount) {
+    const activeGoal = getActiveGoal(this.sessionId);
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "" },
+      _meta: {
+        stopHookLoop: {
+          iterationCount,
+          reasons,
+          stopHookCount,
+          ...activeGoal ? {
+            goal: {
+              condition: activeGoal.condition,
+              iterations: activeGoal.iterations,
+              setAt: activeGoal.setAt,
+              lastReason: activeGoal.lastReason
+            }
+          } : {}
+        }
+      }
+    });
+  }
+  async emitGoalStatus(status) {
+    await this.sendUpdate(buildGoalStatusUpdate(status));
+  }
+  async emitGoalState(snapshot, cause, previousGoal = null) {
+    await this.sendUpdate(buildGoalStateUpdate(snapshot, cause, previousGoal));
+  }
+  /**
+   * Emits a user message chunk.
+   *
+   * @param text - The user message text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
+   */
+  async emitUserMessage(text, timestamp, options = {}) {
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "user",
+        text,
+        timestamp,
+        ...options.source ? { extra: { source: options.source } } : {}
+      })
+    );
+  }
+  /**
+   * Emits an agent thought chunk.
+   *
+   * @param text - The thought text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
+   */
+  async emitAgentThought(text, timestamp, subagentMeta) {
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "assistant",
+        thought: true,
+        text,
+        timestamp,
+        ...subagentMeta ? { extra: { ...subagentMeta } } : {}
+      })
+    );
+  }
+  /**
+   * Emits an agent message chunk.
+   *
+   * @param text - The agent message text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
+   */
+  async emitAgentMessage(text, timestamp, subagentMeta) {
+    await this.sendUpdate(
+      createTranscriptMessageUpdate({
+        role: "assistant",
+        text,
+        timestamp,
+        ...subagentMeta ? { extra: { ...subagentMeta } } : {}
+      })
+    );
+  }
+  async emitSlashCommandOutput(text, timestamp) {
+    const epochMs = BaseEmitter.toEpochMs(timestamp);
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text },
+      _meta: {
+        source: "slash_command",
+        ...epochMs != null ? { timestamp: epochMs } : {}
+      }
+    });
+  }
+  /**
+   * Emits usage metadata.
+   */
+  async emitUsageMetadata(usageMetadata, text = "", durationMs, subagentMeta) {
+    const cumulative = this.ctx.cumulativeUsage;
+    if (cumulative) {
+      const addFinite = /* @__PURE__ */ __name((total, value) => typeof value === "number" && Number.isFinite(value) ? total + value : total, "addFinite");
+      cumulative.promptTokens = addFinite(
+        cumulative.promptTokens,
+        usageMetadata.promptTokenCount
+      );
+      cumulative.candidateTokens = addFinite(
+        cumulative.candidateTokens,
+        usageMetadata.candidatesTokenCount
+      );
+      cumulative.cachedTokens = addFinite(
+        cumulative.cachedTokens,
+        usageMetadata.cachedContentTokenCount
+      );
+      cumulative.apiTimeMs = addFinite(cumulative.apiTimeMs, durationMs);
+    }
+    let activityMeta = {};
+    if (typeof durationMs === "number") {
+      const activity = apiActivityTracker.drain();
+      activityMeta = {
+        ...activity.errors > 0 ? { apiErrors: activity.errors } : {},
+        ...activity.retries > 0 ? { apiRetries: activity.retries } : {}
+      };
+    }
+    await this.sendUpdate(
+      createTranscriptUsageUpdate(usageMetadata, {
+        text,
+        extra: {
+          ...typeof durationMs === "number" ? { durationMs } : {},
+          ...activityMeta,
+          ...subagentMeta
+        }
+      })
+    );
+    if (!Number.isFinite(durationMs) || subagentMeta || !hasFullSessionContext(this.ctx)) {
+      return;
+    }
+    const used = usageMetadata.promptTokenCount ?? usageMetadata.totalTokenCount;
+    const size = this.ctx.config.getContentGeneratorConfig()?.contextWindowSize;
+    if (typeof used !== "number" || !Number.isSafeInteger(used) || used < 0 || typeof size !== "number" || !Number.isSafeInteger(size) || size <= 0) {
+      return;
+    }
+    await this.sendUpdate({
+      sessionUpdate: "usage_update",
+      used,
+      size
+    });
+  }
+  /**
+   * Emits a message chunk based on role and thought flag.
+   * This is the unified method that handles all message types.
+   *
+   * @param text - The message text content
+   * @param role - Whether this is a user or assistant message
+   * @param isThought - Whether this is an assistant thought (only applies to assistant role)
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
+   */
+  async emitMessage(text, role, isThought = false, timestamp, subagentMeta) {
+    if (role === "user") {
+      return this.emitUserMessage(text, timestamp);
+    }
+    return isThought ? this.emitAgentThought(text, timestamp, subagentMeta) : this.emitAgentMessage(text, timestamp, subagentMeta);
+  }
+};
+
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
 
@@ -2678,6 +2961,7 @@ __name(reduceRepeatedToolFailureGuard, "reduceRepeatedToolFailureGuard");
 var debugLogger6 = createDebugLogger("SESSION");
 var permissionRequestTails = /* @__PURE__ */ new WeakMap();
 var USER_CANCEL_ABORT_REASON = "qwen:user-cancel";
+var NEW_PROMPT_ABORT_REASON = "qwen:new-prompt";
 var SESSION_DISPOSE_ABORT_REASON = "qwen:session-dispose";
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
 var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
@@ -2725,6 +3009,61 @@ function getAbortAwareEndTurnStopReason(signal) {
   return signal.aborted ? "cancelled" : "end_turn";
 }
 __name(getAbortAwareEndTurnStopReason, "getAbortAwareEndTurnStopReason");
+function sameGoalPermit(left, right) {
+  return left?.goalId === right.goalId && left.revision === right.revision && left.turnId === right.turnId;
+}
+__name(sameGoalPermit, "sameGoalPermit");
+function buildGoalContinuationParts(turn) {
+  return [
+    {
+      text: [
+        "Continue working on the active Goal.",
+        "Use get_goal for the authoritative objective and evidence state.",
+        "Follow the objective's requested output format exactly. Do not add progress, status, or completion commentary unless the objective asks for it.",
+        "If completion depends on content delivered in this turn, deliver only that content and call get_goal in the same response before update_goal.",
+        `Runtime continuation context: ${turn.continuationContext}`,
+        ...turn.verifierFeedback ? [`Verifier feedback: ${turn.verifierFeedback}`] : []
+      ].join("\n")
+    }
+  ];
+}
+__name(buildGoalContinuationParts, "buildGoalContinuationParts");
+async function claimGoalTurn(runtime, turnKey, signal) {
+  if (signal.aborted) return void 0;
+  const immediate = runtime.permitForTurn(turnKey) ?? runtime.beginTurn(turnKey);
+  if (immediate || runtime.getSnapshot().goal?.status !== "active") {
+    return immediate;
+  }
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    let unsubscribe = /* @__PURE__ */ __name(() => {
+    }, "unsubscribe");
+    const finish = /* @__PURE__ */ __name((permit, error) => {
+      if (settled) return;
+      settled = true;
+      unsubscribe();
+      signal.removeEventListener("abort", onAbort);
+      if (error !== void 0) reject(error);
+      else resolve6(permit);
+    }, "finish");
+    const inspect = /* @__PURE__ */ __name(() => {
+      try {
+        const permit = runtime.permitForTurn(turnKey);
+        if (permit || runtime.getSnapshot().goal?.status !== "active") {
+          finish(permit);
+        }
+      } catch (error) {
+        finish(void 0, error);
+      }
+    }, "inspect");
+    const onAbort = /* @__PURE__ */ __name(() => finish(void 0), "onAbort");
+    unsubscribe = runtime.subscribe(inspect);
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    else inspect();
+  });
+}
+__name(claimGoalTurn, "claimGoalTurn");
 var DAEMON_INVALID_TOOL_PARAMS_THRESHOLD = 3;
 var PERMISSION_CANCEL_SKIP_MESSAGE = "Skipped because a permission request was cancelled before the user answered; user input is required before continuing.";
 var LOOP_DETECTED_SKIP_MESSAGE = "Skipped because loop detection stopped the current turn before this tool call could run.";
@@ -3346,11 +3685,9 @@ var Session = class {
     this.todoStopGuardBackgroundBaseline = this.#captureTodoStopGuardBackgroundBaseline();
     this.toolCallEmitter = new ToolCallEmitter(this);
     this.planEmitter = new PlanEmitter(this);
-    this.historyReplayer = new HistoryReplayer(this, {
-      supersedeUnrestorableGoal: true
-    });
+    this.historyReplayer = new HistoryReplayer(this);
     this.messageEmitter = new MessageEmitter(this);
-    this.installGoalTerminalObserver();
+    this.#bindGoalRuntime();
     this.#registerBackgroundNotificationCallbacks();
     this.#registerSubSessionSpawner();
     this.config.getWorkflowRunRegistry?.().setApprovalRequestCallback(
@@ -3438,6 +3775,14 @@ var Session = class {
   persistedBackgroundNotificationTaskIds = /* @__PURE__ */ new Set();
   backgroundNotificationAcceptances = /* @__PURE__ */ new Map();
   activeAgentNotificationAcceptances = /* @__PURE__ */ new Set();
+  goalQueue = [];
+  goalProcessing = false;
+  activeGoalTurn;
+  goalHostUnbind;
+  goalRuntimeUnsubscribe;
+  lastGoalSnapshot;
+  lastGoalPublicationKey;
+  goalPublicationTail = Promise.resolve();
   // Set true in dispose(). Guards #drainCronQueue and #drainNotificationQueue
   // against the race where #drainNotificationQueue's finally block kicks off
   // #drainCronQueue after the session has already been disposed (e.g. /clear
@@ -3483,6 +3828,311 @@ var Session = class {
   pendingRecoveredAgentsNotice = null;
   // Implement SessionContext interface
   sessionId;
+  #bindGoalRuntime() {
+    try {
+      const runtime = this.config.getGoalRuntime();
+      this.lastGoalSnapshot = runtime.getSnapshot();
+      this.goalRuntimeUnsubscribe = runtime.subscribe((snapshot, cause) => {
+        const previousGoal = this.lastGoalSnapshot?.goal ?? null;
+        this.lastGoalSnapshot = snapshot;
+        void this.#queueGoalState(snapshot, cause, previousGoal).catch(
+          (error) => debugLogger6.warn(
+            `Failed to emit ACP Goal state: ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+      });
+      const host = {
+        startGoalTurn: /* @__PURE__ */ __name(async (input) => {
+          if (this.goalQueue.some(
+            ({ permit }) => permit.turnId === input.permit.turnId
+          ) || this.activeGoalTurn?.permit.turnId === input.permit.turnId) {
+            return;
+          }
+          this.goalQueue.push({
+            permit: { ...input.permit },
+            turnKey: `goal-runtime:${input.permit.turnId}`,
+            controller: new AbortController(),
+            origin: "runtime",
+            continuationContext: input.continuationContext,
+            ...input.verifierFeedback ? { verifierFeedback: input.verifierFeedback } : {},
+            modelStarted: false
+          });
+          void this.#drainGoalQueue();
+        }, "startGoalTurn"),
+        preemptGoalTurn: /* @__PURE__ */ __name((reason) => {
+          for (const turn of this.goalQueue.splice(0)) {
+            turn.controller.abort(reason);
+          }
+          this.activeGoalTurn?.controller.abort(reason);
+        }, "preemptGoalTurn")
+      };
+      this.goalHostUnbind = this.config.bindGoalTurnHost(host);
+    } catch (error) {
+      if (!(error instanceof GoalPersistenceUnavailableError)) {
+        throw error;
+      }
+      debugLogger6.debug("Canonical Goal runtime is unavailable for ACP");
+    }
+  }
+  /**
+   * Re-attach this session to the Goal runtime after `/clear`.
+   *
+   * `Config.startNewSession()` disposes the old runtime and builds a fresh
+   * one, so the `subscribe` callback installed by `#bindGoalRuntime` — the
+   * only path that reaches `MessageEmitter.emitGoalState` — would stay
+   * registered on the abandoned instance and the client would never receive
+   * another `_meta.goalState` update. The retained turn host survives the
+   * switch, but the subscription and the publication de-duplication state
+   * belong to the old runtime and have to be rebuilt.
+   */
+  rebindGoalRuntimeForNewSession() {
+    if (this.disposed || this.closing) return;
+    this.goalRuntimeUnsubscribe?.();
+    this.goalRuntimeUnsubscribe = void 0;
+    this.goalHostUnbind?.();
+    this.goalHostUnbind = void 0;
+    this.lastGoalSnapshot = void 0;
+    this.lastGoalPublicationKey = void 0;
+    this.#bindGoalRuntime();
+  }
+  /**
+   * Publish the recovered Goal state once, after history replay.
+   *
+   * Goal recovery runs from the `Config` constructor, long before this
+   * Session exists, so `restore()`'s correction broadcast reaches zero
+   * listeners — and replay streams the pre-migration records, emitting the
+   * legacy `set` card. Clients that derive the live goal from goal cards
+   * (both web-shell and the daemon provider do) are therefore left showing a
+   * goal as running when the migrated goal is `paused` and nothing drives
+   * it; only a second reload self-corrected. Republishing here puts the
+   * authoritative state *after* the replayed card, which is the ordering
+   * that matters. `#publishGoalState` de-duplicates on `(cause, snapshot)`,
+   * so this is a no-op when the subscription already delivered it.
+   *
+   * When recovery failed outright — a malformed or future-schema
+   * `goal_state` record makes `recoverGoalFromRecords` return `unsupported`
+   * — there is no state to publish and no in-session command can correct the
+   * stream, because a degraded `/goal` answers without a cause. That case
+   * gets the same trailing `cleared` card the replay-time
+   * `supersedeUnrestorableGoal` used to emit.
+   */
+  async publishRecoveredGoalState(replayedRecords) {
+    if (this.disposed || this.closing) return;
+    let runtime;
+    try {
+      runtime = await this.config.getGoalRuntimeReady();
+    } catch (error) {
+      if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+      await this.#supersedeUnrestorableGoal(replayedRecords);
+      return;
+    }
+    const cause = runtime.getRecoveryCause?.();
+    if (!cause) return;
+    await this.#queueGoalState(runtime.getSnapshot(), cause);
+  }
+  /**
+   * Render the recovered-Goal cards instead of streaming them.
+   *
+   * The bulk load-replay path (`historyReplay: 'response'`) does not stream
+   * its replay: `loadSession` collects the page into the `LOAD_REPLAY`
+   * envelope and the bridge seeds those updates onto the session's event bus
+   * *after* the ACP `session/load` call returns. A card streamed from inside
+   * that call therefore lands on the bus **before** the replayed
+   * pre-migration `set` card — the reverse of the ordering
+   * {@link publishRecoveredGoalState} exists to produce, leaving the phantom
+   * running goal exactly as it was. Returning the cards lets the caller
+   * append them to the envelope, after the replay page.
+   *
+   * Appending after a truncated page (`hasMore`) is still correct: paging
+   * drops the oldest records, so the authoritative state belongs last either
+   * way.
+   *
+   * Marks the publication as delivered, so the runtime subscription cannot
+   * emit a duplicate card for the same `(cause, snapshot)` once the session
+   * goes live.
+   */
+  async renderRecoveredGoalUpdates(replayedRecords) {
+    if (this.disposed || this.closing) return [];
+    let runtime;
+    try {
+      runtime = await this.config.getGoalRuntimeReady();
+    } catch (error) {
+      if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+      const status = this.#unrestorableGoalStatus(replayedRecords);
+      return status ? [buildGoalStatusUpdate(status)] : [];
+    }
+    const cause = runtime.getRecoveryCause?.();
+    if (!cause) return [];
+    const snapshot = runtime.getSnapshot();
+    const publicationKey = this.#goalPublicationKey(snapshot, cause);
+    if (publicationKey === this.lastGoalPublicationKey) return [];
+    this.lastGoalPublicationKey = publicationKey;
+    return [
+      buildGoalStateUpdate(
+        snapshot,
+        cause,
+        this.lastGoalSnapshot?.goal ?? null
+      )
+    ];
+  }
+  /**
+   * Emit a trailing `cleared` card for an active legacy goal the runtime
+   * refused to recover.
+   *
+   * Emitted, not recorded: the transcript keeps its `set` card, so a later
+   * resume that can recover the goal still finds it.
+   */
+  async #supersedeUnrestorableGoal(replayedRecords) {
+    const status = this.#unrestorableGoalStatus(replayedRecords);
+    if (!status) return;
+    await this.messageEmitter.emitGoalStatus(status);
+  }
+  /**
+   * The `cleared` card for an active legacy goal the runtime refused to
+   * recover, or `undefined` when there is nothing to supersede. Shared by the
+   * streaming and rendering recovery paths so they cannot drift.
+   */
+  #unrestorableGoalStatus(replayedRecords) {
+    if (!replayedRecords?.length) return void 0;
+    const active = findGoalToRestore(
+      collectGoalStatusItemsFromRecords(replayedRecords)
+    );
+    if (!active) return void 0;
+    return {
+      kind: "cleared",
+      condition: active.condition,
+      iterations: active.iterations,
+      ...active.setAt !== void 0 ? { setAt: active.setAt } : {},
+      lastReason: "Goal not restored: its saved state could not be read, so this session is not driving it."
+    };
+  }
+  #goalPublicationKey(snapshot, cause) {
+    return cause ? `${cause}:${JSON.stringify(snapshot)}` : void 0;
+  }
+  async #publishGoalState(snapshot, cause, previousGoal = this.lastGoalSnapshot?.goal ?? null) {
+    const publicationKey = this.#goalPublicationKey(snapshot, cause);
+    if (publicationKey && publicationKey === this.lastGoalPublicationKey) {
+      return;
+    }
+    if (publicationKey) this.lastGoalPublicationKey = publicationKey;
+    await this.messageEmitter.emitGoalState(snapshot, cause, previousGoal);
+  }
+  #queueGoalState(snapshot, cause, previousGoal = this.lastGoalSnapshot?.goal ?? null) {
+    const publication = this.goalPublicationTail.then(
+      () => this.#publishGoalState(snapshot, cause, previousGoal)
+    );
+    this.goalPublicationTail = publication.catch(() => void 0);
+    return publication;
+  }
+  async #drainGoalQueue() {
+    if (this.disposed || this.closing || this.goalProcessing || this.pendingPrompt || this.pendingPromptCompletion || this.cronProcessing || this.cronAbortController || this.notificationProcessing || this.notificationAbortController) {
+      return;
+    }
+    const turn = this.goalQueue.shift();
+    if (!turn) return;
+    this.goalProcessing = true;
+    this.activeGoalTurn = turn;
+    const parts = buildGoalContinuationParts(turn);
+    try {
+      await this.prompt(
+        {
+          sessionId: this.sessionId,
+          prompt: parts.map((part) => ({
+            type: "text",
+            text: part.text ?? ""
+          }))
+        },
+        void 0,
+        void 0,
+        void 0,
+        turn
+      );
+    } catch (error) {
+      await this.#settleGoalTurn(turn, void 0, true);
+      debugLogger6.warn(
+        `ACP Goal turn failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      if (this.activeGoalTurn === turn) this.activeGoalTurn = void 0;
+      this.goalProcessing = false;
+      void this.#drainCronQueue();
+      void this.#drainNotificationQueue();
+      void this.#drainGoalQueue();
+    }
+  }
+  async #settleGoalTurn(turn, result, failed) {
+    try {
+      const runtime = await this.config.getGoalRuntimeReady();
+      if (!sameGoalPermit(runtime.permitForTurn(turn.turnKey), turn.permit)) {
+        return;
+      }
+      if (!turn.modelStarted) {
+        if (turn.controller.signal.reason === USER_CANCEL_ABORT_REASON && runtime.getSnapshot().goal?.status === "active") {
+          await runtime.dispatch({
+            action: "pause",
+            expectedGoalId: turn.permit.goalId,
+            expectedRevision: turn.permit.revision
+          });
+        } else {
+          await runtime.releaseTurn(turn.turnKey);
+        }
+        return;
+      }
+      try {
+        await this.config.getChatRecordingService()?.flush();
+      } catch (error) {
+        debugLogger6.warn(
+          `Failed to flush ACP Goal turn: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      const cancelledByUser = result?.stopReason === "cancelled" && turn.controller.signal.reason === USER_CANCEL_ABORT_REASON;
+      const supersededByNewPrompt = turn.controller.signal.reason === NEW_PROMPT_ABORT_REASON;
+      const shouldPause = !supersededByNewPrompt && (failed || result?.stopReason === "max_tokens" || cancelledByUser || turn.controller.signal.reason === SESSION_DISPOSE_ABORT_REASON);
+      try {
+        if (shouldPause && runtime.getSnapshot().goal?.status === "active") {
+          await runtime.dispatch({
+            action: "pause",
+            expectedGoalId: turn.permit.goalId,
+            expectedRevision: turn.permit.revision
+          });
+          return;
+        }
+        await runtime.finishTurn(turn.permit);
+      } catch (error) {
+        debugLogger6.warn(
+          `Failed to record ACP Goal turn settlement: ${error instanceof Error ? error.message : String(error)}`
+        );
+        await runtime.releaseTurn(turn.turnKey);
+      }
+    } catch (error) {
+      debugLogger6.warn(
+        `Failed to settle ACP Goal turn: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Stops an autonomous Goal loop when the Stop-hook blocking cap fires.
+   *
+   * `abortGoalForStopHookCap` only knows about the legacy `activeGoalStore`,
+   * which no longer has a writer for daemon sessions, so ACP needs the
+   * canonical runtime acted on directly.
+   */
+  async #pauseGoalForStopHookCap() {
+    try {
+      const runtime = await this.config.getGoalRuntimeReady();
+      const goal = runtime.getSnapshot().goal;
+      if (goal?.status !== "active") return;
+      await runtime.dispatch({
+        action: "pause",
+        expectedGoalId: goal.goalId,
+        expectedRevision: goal.revision
+      });
+    } catch (error) {
+      debugLogger6.warn(
+        `Failed to pause the Goal after the Stop hook cap: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   async #requestWorkflowApproval(runId, approval, rawArgs, approvalSignal) {
     const registry = this.config.getWorkflowRunRegistry();
     const externalToolCallId = `workflow:${this.sessionId}:${runId}:${approval.approvalId}`;
@@ -4136,7 +4786,7 @@ var Session = class {
   }
   #hasActiveTurn() {
     return Boolean(
-      this.pendingPrompt || this.pendingPromptCompletion || this.cronProcessing || this.cronAbortController || this.cronCompletion || this.notificationProcessing || this.notificationAbortController || this.notificationCompletion
+      this.pendingPrompt || this.pendingPromptCompletion || this.goalProcessing || this.cronProcessing || this.cronAbortController || this.cronCompletion || this.notificationProcessing || this.notificationAbortController || this.notificationCompletion
     );
   }
   beginClose() {
@@ -4164,6 +4814,7 @@ var Session = class {
       resolveGate();
       if (this.disposed) return;
       this.closing = false;
+      void this.#drainGoalQueue();
       void this.#drainCronQueue();
       void this.#drainNotificationQueue();
     };
@@ -4227,6 +4878,14 @@ var Session = class {
     this.hardSuspendTodoStopGuard();
     this.notificationQueue = [];
     this.cronQueue = [];
+    for (const turn of this.goalQueue.splice(0)) {
+      turn.controller.abort(SESSION_DISPOSE_ABORT_REASON);
+    }
+    this.activeGoalTurn?.controller.abort(SESSION_DISPOSE_ABORT_REASON);
+    this.goalHostUnbind?.();
+    this.goalHostUnbind = void 0;
+    this.goalRuntimeUnsubscribe?.();
+    this.goalRuntimeUnsubscribe = void 0;
     this.notificationAbortController?.abort();
     this.notificationAbortController = null;
     this.notificationProcessing = false;
@@ -4254,7 +4913,6 @@ var Session = class {
     this.config.setSubSessionSpawner(void 0);
     this.config.getWorkflowRunRegistry?.().setApprovalRequestCallback(void 0);
     this.workflowApprovalAbortController.abort(SESSION_DISPOSE_ABORT_REASON);
-    clearGoalTerminalObserver(this.sessionId);
   }
   /**
    * Install the message rewrite middleware if configured.
@@ -4271,43 +4929,6 @@ var Session = class {
       );
     }
   }
-  /**
-   * Installs (or replaces) this session's goal-terminal observer.
-   *
-   * Public because it does not stay installed: `registerGoalHook` and
-   * `unregisterGoalHook` both clear the observer table for the session, so any
-   * caller that (re-)registers a goal outside `#processSlashCommandResult` —
-   * notably goal restore on resume — has to put it back. Idempotent.
-   */
-  installGoalTerminalObserver() {
-    setGoalTerminalObserver(this.sessionId, (event) => {
-      void this.messageEmitter.emitGoalTerminal(event).catch((error) => {
-        debugLogger6.warn(
-          `Failed to emit goal terminal update: ${this.#formatError(error)}`
-        );
-      });
-      recordGoalStatusItem(this.config, goalTerminalEventToHistoryItem(event));
-    });
-  }
-  /**
-   * Emits a goal card and persists it to the transcript. Both `set` and
-   * `cleared` reach the client this way — from `#emitGoalStatusItems` for a
-   * `/goal` prompt, and from the `sessionGoalClear` ext method — so recording
-   * here (rather than at each call site) keeps the transcript in step with the
-   * hook. Replay goes through `messageEmitter.emitGoalStatus` directly and so
-   * does not re-record.
-   */
-  emitGoalStatus(status) {
-    void this.messageEmitter.emitGoalStatus(status).catch((error) => {
-      debugLogger6.warn(
-        `Failed to emit goal status update: ${this.#formatError(error)}`
-      );
-    });
-    recordGoalStatusItem(this.config, {
-      type: "goal_status" /* GOAL_STATUS */,
-      ...status
-    });
-  }
   /**
    * Replays conversation history to the client using modular components.
    * Delegates to HistoryReplayer for consistent event emission.
@@ -4446,11 +5067,13 @@ var Session = class {
     const hadPrompt = !!this.pendingPrompt;
     const hadCron = !!this.cronAbortController;
     const hadNotification = !!this.notificationAbortController || this.notificationProcessing;
+    const queuedGoalTurns = this.goalQueue.splice(0);
+    const hadQueuedGoalTurn = queuedGoalTurns.length > 0;
     if (this.followupAbort) {
       this.followupAbort.abort();
       this.followupAbort = null;
     }
-    if (!hadPrompt && !hadCron && !hadNotification) {
+    if (!hadPrompt && !hadCron && !hadNotification && !hadQueuedGoalTurn) {
       throw new Error(NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE);
     }
     this.todoStopGuard.suspend();
@@ -4458,6 +5081,9 @@ var Session = class {
       this.pendingPrompt.abort(USER_CANCEL_ABORT_REASON);
       this.pendingPrompt = null;
     }
+    for (const turn of queuedGoalTurns) {
+      turn.controller.abort(USER_CANCEL_ABORT_REASON);
+    }
     if (this.cronAbortController) {
       this.cronAbortController.abort();
       this.cronAbortController = null;
@@ -4470,6 +5096,26 @@ var Session = class {
     }
     this.notificationQueue = [];
     this.notificationProcessing = false;
+    const queuedGoalTurn = queuedGoalTurns[0];
+    if (queuedGoalTurn) {
+      try {
+        const runtime = this.config.getGoalRuntime();
+        if (sameGoalPermit(
+          runtime.permitForTurn(queuedGoalTurn.turnKey),
+          queuedGoalTurn.permit
+        ) && runtime.getSnapshot().goal?.status === "active") {
+          await runtime.dispatch({
+            action: "pause",
+            expectedGoalId: queuedGoalTurn.permit.goalId,
+            expectedRevision: queuedGoalTurn.permit.revision
+          });
+        }
+      } catch (error) {
+        debugLogger6.warn(
+          `Failed to pause queued ACP Goal turn: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
     this.#activeWorkChanged();
     const scheduler = this.config.isCronEnabled() ? this.config.getCronScheduler() : null;
     if (scheduler) {
@@ -4480,7 +5126,7 @@ var Session = class {
       }
     }
   }
-  async prompt(params, invocationContext, admissionCancellation, modelPrompt) {
+  async prompt(params, invocationContext, admissionCancellation, modelPrompt, scheduledGoalTurn) {
     if (this.closing) {
       throw RequestError.invalidParams(void 0, "Session is closing");
     }
@@ -4507,8 +5153,27 @@ var Session = class {
       return { stopReason: "cancelled" };
     }
     const todoStopGuardPreparation = this.#prepareTodoStopGuardForPrompt(params);
-    this.pendingPrompt?.abort();
-    const pendingSend = new AbortController();
+    let goalTurn = scheduledGoalTurn;
+    let reservedGoalRuntime;
+    let reservedGoalTurnKey;
+    if (!goalTurn) {
+      try {
+        const runtime = this.config.getGoalRuntime();
+        if (runtime.getSnapshot().goal?.status === "active") {
+          reservedGoalRuntime = runtime;
+          reservedGoalTurnKey = `goal-user:${randomUUID()}`;
+          runtime.beginTurn(reservedGoalTurnKey);
+          for (const queued of this.goalQueue.splice(0)) {
+            queued.controller.abort(NEW_PROMPT_ABORT_REASON);
+            await runtime.releaseTurn(queued.turnKey);
+          }
+        }
+      } catch (error) {
+        if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+      }
+    }
+    this.pendingPrompt?.abort(NEW_PROMPT_ABORT_REASON);
+    const pendingSend = goalTurn?.controller ?? new AbortController();
     const cancelPendingSend = /* @__PURE__ */ __name(() => pendingSend.abort(USER_CANCEL_ABORT_REASON), "cancelPendingSend");
     if (admissionCancellation) {
       admissionCancellation.addEventListener("abort", cancelPendingSend, {
@@ -4558,7 +5223,46 @@ var Session = class {
       } catch {
       }
     }
+    if (reservedGoalRuntime && reservedGoalTurnKey) {
+      try {
+        const permit = await claimGoalTurn(
+          reservedGoalRuntime,
+          reservedGoalTurnKey,
+          pendingSend.signal
+        );
+        if (permit) {
+          const goal = reservedGoalRuntime.getSnapshot().goal;
+          if (goal) {
+            const verifierFeedback = reservedGoalRuntime.getVerifierFeedback(permit);
+            goalTurn = {
+              permit,
+              turnKey: reservedGoalTurnKey,
+              controller: pendingSend,
+              origin: "user",
+              continuationContext: goal.objective,
+              ...verifierFeedback ? { verifierFeedback } : {},
+              modelStarted: false
+            };
+          }
+        }
+      } catch (error) {
+        try {
+          await reservedGoalRuntime.releaseTurn(reservedGoalTurnKey);
+        } catch (releaseError) {
+          debugLogger6.warn(
+            `Failed to release Goal reservation after admission failure: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`
+          );
+        } finally {
+          releasePendingSend();
+          this.todoStopGuard.suspend();
+        }
+        throw error;
+      }
+    }
     if (pendingSend.signal.aborted) {
+      if (reservedGoalRuntime && reservedGoalTurnKey) {
+        await reservedGoalRuntime.releaseTurn(reservedGoalTurnKey);
+      }
       releasePendingSend();
       this.todoStopGuard.suspend();
       return { stopReason: "cancelled" };
@@ -4575,14 +5279,18 @@ var Session = class {
     this.pendingPromptCompletion = new Promise((resolve6) => {
       resolveCompletion = resolve6;
     });
+    let promptResult;
+    let promptFailed = false;
     try {
       const result = await this.#executePrompt(
         params,
         pendingSend,
         channelDeliveryCapture,
         invocationContext,
-        modelPrompt
+        modelPrompt,
+        goalTurn
       );
+      promptResult = result;
       releasePendingSend();
       void this.#drainCronQueue();
       void this.#drainNotificationQueue();
@@ -4601,6 +5309,7 @@ var Session = class {
       }
       return result;
     } catch (error) {
+      promptFailed = true;
       if (error instanceof SessionWriterError) {
         throw new RequestError(error.rpcCode, error.message, {
           errorKind: error.errorKind
@@ -4618,9 +5327,15 @@ var Session = class {
         void this.#drainCronQueue();
         void this.#drainNotificationQueue();
       }
+      if (goalTurn) {
+        await this.#settleGoalTurn(goalTurn, promptResult, promptFailed);
+      } else if (reservedGoalRuntime && reservedGoalTurnKey) {
+        await reservedGoalRuntime.releaseTurn(reservedGoalTurnKey);
+      }
       void this.#startCronSchedulerInRuntime();
       resolveCompletion();
       this.pendingPromptCompletion = null;
+      void this.#drainGoalQueue();
       await this.#consumeLiveEndInstruction();
     }
   }
@@ -4742,7 +5457,7 @@ var Session = class {
       }
     })();
   }
-  async #executePrompt(params, pendingSend, channelDeliveryCapture, invocationContext, modelPrompt) {
+  async #executePrompt(params, pendingSend, channelDeliveryCapture, invocationContext, modelPrompt, goalTurn) {
     const sessionId = this.config.getSessionId();
     if (invocationContext !== void 0 && invocationContext.sessionId !== sessionId) {
       throw RequestError.invalidParams(
@@ -4750,7 +5465,7 @@ var Session = class {
         "Invocation context session does not match the active session"
       );
     }
-    return runWithInvocationContext(
+    const execute = /* @__PURE__ */ __name(() => runWithInvocationContext(
       invocationContext,
       () => sessionIdContext.run(
         sessionId,
@@ -4758,12 +5473,14 @@ var Session = class {
           params,
           pendingSend,
           channelDeliveryCapture,
-          modelPrompt
+          modelPrompt,
+          goalTurn
         )
       )
-    );
+    ), "execute");
+    return goalTurn ? goalTurnContext.run(goalTurn.permit, execute) : goalTurnContext.exit(execute);
   }
-  async #executePromptInner(params, pendingSend, channelDeliveryCapture, modelPrompt) {
+  async #executePromptInner(params, pendingSend, channelDeliveryCapture, modelPrompt, goalTurn) {
     return Storage.runWithRuntimeBaseDir(
       this.runtimeBaseDir,
       this.config.getWorkingDir(),
@@ -4788,6 +5505,7 @@ var Session = class {
           },
           async () => {
             const promptText = params.prompt.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join(" ");
+            const promptDisplayText = typeof promptMetadata?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] === "string" ? promptMetadata[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] : void 0;
             const modelPromptBlocks = modelPrompt === void 0 ? params.prompt : [{ type: "text", text: modelPrompt }];
             logUserPrompt(
               this.config,
@@ -4803,7 +5521,12 @@ var Session = class {
             let continuationParts = null;
             let strippedOrphanEntries = null;
             let orphanPushCountSnapshot = 0;
-            if (isContinue) {
+            if (goalTurn?.origin === "runtime") {
+              this.config.getChatRecordingService()?.recordGoalRuntimeMessage(
+                modelPromptBlocks.filter((block) => block.type === "text").map((block) => ({ text: block.text })),
+                goalTurn.permit
+              );
+            } else if (isContinue) {
               const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({
                 sessionId: this.sessionId,
                 apiHistory: this.#getCurrentChat().getHistory()
@@ -4829,11 +5552,22 @@ var Session = class {
                 continuationParts = recoveryPlan.continuation.parts;
               }
             }
-            if (isContinue) {
+            if (goalTurn?.origin === "runtime") {
+            } else if (isContinue) {
             } else if (isRetry) {
               this.#getCurrentChat().stripOrphanedUserEntriesFromHistory();
             } else {
-              this.config.getChatRecordingService()?.recordUserMessage(promptText);
+              const recorder = this.config.getChatRecordingService();
+              if (promptDisplayText !== void 0) {
+                recorder?.recordUserMessage(promptText, goalTurn?.permit, {
+                  displayText: promptDisplayText,
+                  hookContext: ""
+                });
+              } else if (goalTurn) {
+                recorder?.recordUserMessage(promptText, goalTurn.permit);
+              } else {
+                recorder?.recordUserMessage(promptText);
+              }
             }
             const firstTextBlock = modelPromptBlocks.find(
               (block) => block.type === "text"
@@ -4862,7 +5596,13 @@ var Session = class {
                 inputText,
                 pendingSend,
                 this.config,
-                this.settings
+                this.settings,
+                {
+                  // `/clear` swaps in a new Goal runtime under this
+                  // long-lived Session; without this the goal-state
+                  // subscription stays on the disposed instance.
+                  startNewSession: /* @__PURE__ */ __name(() => this.rebindGoalRuntimeForNewSession(), "startNewSession")
+                }
               );
               parts = await this.#processSlashCommandResult(
                 slashCommandResult,
@@ -4882,7 +5622,8 @@ var Session = class {
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
             const messageBus = this.config.getMessageBus?.();
-            if (!isContinue && hooksEnabled && messageBus && this.config.hasHooksForEvent?.("UserPromptSubmit")) {
+            const isRuntimeContinuation = goalTurn?.origin === "runtime";
+            if (!isContinue && !isRuntimeContinuation && hooksEnabled && messageBus && this.config.hasHooksForEvent?.("UserPromptSubmit")) {
               const response = await messageBus.request(
                 {
                   type: "hook-execution-request" /* HOOK_EXECUTION_REQUEST */,
@@ -4996,6 +5737,7 @@ ${this.pendingRecoveredAgentsNotice}
                 );
                 let channelDeliveryResponseBlock;
                 try {
+                  if (goalTurn) goalTurn.modelStarted = true;
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
                     nextMessage?.parts ?? [],
@@ -5404,11 +6146,13 @@ ${this.pendingRecoveredAgentsNotice}
           "Stop",
           stopHookBlockingCap
         );
-        abortGoalForStopHookCap(
+        if (!abortGoalForStopHookCap(
           this.config,
           this.config.getSessionId(),
           warning
-        );
+        )) {
+          await this.#pauseGoalForStopHookCap();
+        }
         this.todoStopGuard.suspend();
         await this.messageEmitter.emitAgentMessage(warning);
         debugLogger6.warn(warning);
@@ -6149,16 +6893,16 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return { responseStream: null, stopReason: "cancelled" };
     }
-    const responseStream = await this.#getCurrentChat().sendMessageStream(
-      options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel(),
-      {
-        message,
-        config: {
-          abortSignal
-        }
-      },
-      promptId
-    );
+    const chat = this.#getCurrentChat();
+    const model = options.getModelOverride?.() ?? options.modelOverride ?? this.config.getModel();
+    const request = {
+      message,
+      config: {
+        abortSignal
+      }
+    };
+    const goalPermit = goalTurnContext.getStore();
+    const responseStream = goalPermit ? await chat.sendMessageStream(model, request, promptId, goalPermit) : await chat.sendMessageStream(model, request, promptId);
     return { responseStream };
   }
   #preserveUnsentMessageHistory(message, preserveFullMessage) {
@@ -6638,6 +7382,7 @@ ${this.pendingRecoveredAgentsNotice}
     if (this.closing) return;
     if (this.cronProcessing) return;
     if (this.pendingPrompt) return;
+    if (this.goalProcessing) return;
     if (this.notificationProcessing) return;
     if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
     if (this.#nextCronQueueIndex() < 0) return;
@@ -6649,7 +7394,7 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return;
     }
-    if (this.disposed || this.closing || this.cronProcessing || this.pendingPrompt || this.notificationProcessing || this.#nextCronQueueIndex() < 0) {
+    if (this.disposed || this.closing || this.cronProcessing || this.pendingPrompt || this.goalProcessing || this.notificationProcessing || this.#nextCronQueueIndex() < 0) {
       return;
     }
     if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
@@ -6670,6 +7415,7 @@ ${this.pendingRecoveredAgentsNotice}
       this.cronProcessing = false;
       resolveCompletion();
       this.cronCompletion = null;
+      void this.#drainGoalQueue();
       void this.#drainNotificationQueue();
       if (this.config.isCronEnabled()) {
         const scheduler = this.config.getCronScheduler();
@@ -7039,6 +7785,7 @@ ${this.pendingRecoveredAgentsNotice}
     backgroundRegistry.setStatusChangeCallback(this.#statusChangeCallback);
     backgroundRegistry.setNotificationCallback(
       (displayText, modelText, meta) => {
+        const entry = backgroundRegistry.get(meta.agentId);
         this.#enqueueBackgroundNotification({
           displayText,
           modelText,
@@ -7047,7 +7794,12 @@ ${this.pendingRecoveredAgentsNotice}
           kind: "agent",
           continuesTodoStopGuardWorkChain: this.#agentContinuesTodoStopGuardWorkChain(meta.agentId),
           toolUseId: meta.toolUseId,
-          todoWorkChainId: meta.todoWorkChainId
+          todoWorkChainId: meta.todoWorkChainId,
+          structured: entry ? {
+            description: truncateNotificationLabel(
+              buildBackgroundEntryLabel(entry)
+            )
+          } : void 0
         });
       }
     );
@@ -7056,6 +7808,7 @@ ${this.pendingRecoveredAgentsNotice}
       if (meta.status === "running") {
         return;
       }
+      const entry = monitorRegistry.get(meta.monitorId);
       this.#enqueueBackgroundNotification({
         displayText,
         modelText,
@@ -7067,11 +7820,17 @@ ${this.pendingRecoveredAgentsNotice}
           meta.ownerAgentId
         ),
         toolUseId: meta.toolUseId,
-        todoWorkChainId: meta.todoWorkChainId
+        todoWorkChainId: meta.todoWorkChainId,
+        structured: entry ? {
+          description: truncateNotificationLabel(entry.description),
+          eventCount: meta.eventCount,
+          droppedLines: entry.droppedLines || void 0
+        } : void 0
       });
     });
     const shellRegistry = this.config.getBackgroundShellRegistry();
     shellRegistry.setNotificationCallback((displayText, modelText, meta) => {
+      const entry = shellRegistry.get(meta.shellId);
       this.#enqueueBackgroundNotification({
         displayText,
         modelText,
@@ -7079,7 +7838,8 @@ ${this.pendingRecoveredAgentsNotice}
         status: meta.status,
         kind: "shell",
         continuesTodoStopGuardWorkChain: !this.todoStopGuardBackgroundBaseline.shells.has(meta.shellId),
-        todoWorkChainId: meta.todoWorkChainId
+        todoWorkChainId: meta.todoWorkChainId,
+        structured: entry ? { commandLabel: truncateNotificationLabel(entry.description) } : void 0
       });
     });
     this.config.getChatRecordingService()?.setTitleRecordedCallback((customTitle, titleSource, sessionId) => {
@@ -7170,7 +7930,8 @@ ${this.pendingRecoveredAgentsNotice}
           taskId: item.taskId,
           status: item.status,
           kind: item.kind,
-          toolUseId: item.toolUseId
+          toolUseId: item.toolUseId,
+          ...item.structured
         }
       );
     } catch (error) {
@@ -7193,7 +7954,7 @@ ${this.pendingRecoveredAgentsNotice}
     if (this.disposed) return;
     if (this.closing) return;
     if (this.notificationProcessing) return;
-    if (this.pendingPrompt || this.cronProcessing || this.cronAbortController) {
+    if (this.pendingPrompt || this.goalProcessing || this.cronProcessing || this.cronAbortController) {
       return;
     }
     if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
@@ -7207,7 +7968,7 @@ ${this.pendingRecoveredAgentsNotice}
       );
       return;
     }
-    if (this.disposed || this.closing || this.notificationProcessing || this.pendingPrompt || this.cronProcessing || this.cronAbortController || this.#nextNotificationQueueIndex() < 0) {
+    if (this.disposed || this.closing || this.notificationProcessing || this.pendingPrompt || this.goalProcessing || this.cronProcessing || this.cronAbortController || this.#nextNotificationQueueIndex() < 0) {
       return;
     }
     if (this.#deferAutomaticQueueDrainUntilTurnsSettle()) return;
@@ -7218,7 +7979,7 @@ ${this.pendingRecoveredAgentsNotice}
     });
     try {
       while (this.notificationQueue.length > 0) {
-        if (this.pendingPrompt || this.cronProcessing || this.cronAbortController) {
+        if (this.pendingPrompt || this.goalProcessing || this.cronProcessing || this.cronAbortController) {
           break;
         }
         const nextIndex = this.#nextNotificationQueueIndex();
@@ -7245,8 +8006,9 @@ ${this.pendingRecoveredAgentsNotice}
       resolveCompletion();
       this.notificationCompletion = null;
       this.#activeWorkChanged();
+      void this.#drainGoalQueue();
       void this.#drainCronQueue();
-      if (this.notificationQueue.length > 0 && !this.pendingPrompt && !this.cronProcessing && !this.cronAbortController) {
+      if (this.notificationQueue.length > 0 && !this.pendingPrompt && !this.goalProcessing && !this.cronProcessing && !this.cronAbortController) {
         void this.#drainNotificationQueue();
       }
     }
@@ -7283,7 +8045,8 @@ ${this.pendingRecoveredAgentsNotice}
               taskId: item.taskId,
               status: item.status,
               kind: item.kind,
-              toolUseId: item.toolUseId
+              toolUseId: item.toolUseId,
+              ...item.structured
             });
           }
           const notificationReminders = await this.#buildInitialSystemReminders();
@@ -7499,7 +8262,8 @@ ${this.pendingRecoveredAgentsNotice}
           taskId: item.taskId,
           status: item.status,
           kind: item.kind,
-          toolUseId: item.toolUseId
+          toolUseId: item.toolUseId,
+          ...item.structured
         }
       }
     });
@@ -9721,30 +10485,6 @@ ${this.pendingRecoveredAgentsNotice}
       }
     }
   }
-  #emitGoalStatusItems(result) {
-    if (!("outputHistoryItems" in result)) {
-      return;
-    }
-    let hasActiveGoalStatus = false;
-    for (const item of result.outputHistoryItems ?? []) {
-      if (item.type === "goal_status" /* GOAL_STATUS */) {
-        this.emitGoalStatus({
-          kind: item.kind,
-          condition: item.condition,
-          ...item.iterations !== void 0 ? { iterations: item.iterations } : {},
-          ...item.setAt !== void 0 ? { setAt: item.setAt } : {},
-          ...item.durationMs !== void 0 ? { durationMs: item.durationMs } : {},
-          ...item.lastReason !== void 0 ? { lastReason: item.lastReason } : {}
-        });
-        if (!isTerminalGoalStatusKind(item.kind)) {
-          hasActiveGoalStatus = true;
-        }
-      }
-    }
-    if (hasActiveGoalStatus) {
-      this.installGoalTerminalObserver();
-    }
-  }
   /**
    * Processes the result of a slash command execution.
    *
@@ -9762,7 +10502,6 @@ ${this.pendingRecoveredAgentsNotice}
    * @returns Parts to use for the prompt, or null if command was handled without needing model interaction
    */
   async #processSlashCommandResult(result, originalPrompt, abortSignal, onFullTurnModel) {
-    this.#emitGoalStatusItems(result);
     this.refreshContextFilesOnWrite = result.type === "submit_prompt" && Boolean(result.refreshContextFilesOnWrite);
     switch (result.type) {
       case "submit_prompt":
@@ -9813,9 +10552,15 @@ ${this.pendingRecoveredAgentsNotice}
         throw new Error(unsupportedError);
       }
       case "goal_control":
-        throw new Error(
-          "Canonical Goal control is not available in ACP integration yet."
-        );
+        if (!result.cause) {
+          await this.#queueGoalState(
+            result.response.snapshot,
+            void 0,
+            this.lastGoalSnapshot?.goal ?? null
+          );
+          this.lastGoalSnapshot = result.response.snapshot;
+        }
+        return null;
       case "no_command":
         return this.#resolvePrompt(originalPrompt, abortSignal, {
           promptLast: true,
@@ -10362,6 +11107,22 @@ var ActiveWorkReporter = class {
   }
 };
 
+// packages/cli/src/acp-integration/model-configuration.ts
+init_esbuild_shims();
+var MODEL_CONFIGURATIONS = {
+  "qwen3.8-max": {
+    reasoning: {
+      thinking: true,
+      efforts: ["low", "medium", "xhigh"],
+      defaultEffort: "xhigh"
+    }
+  }
+};
+function getModelConfiguration(modelId) {
+  return modelId === "qwen3.8-max" ? MODEL_CONFIGURATIONS[modelId] : void 0;
+}
+__name(getModelConfiguration, "getModelConfiguration");
+
 // packages/cli/src/acp-integration/session/tasksSnapshot.ts
 init_esbuild_shims();
 function runtimeMs(entry, now) {
@@ -10499,6 +11260,7 @@ var BTW_CHILD_TIMEOUT_MS = 55e3;
 var MCP_OAUTH_START_TIMEOUT_MS = 3e4;
 var SESSION_DRAIN_TIMEOUT_MS = 3e4;
 var ACP_REASONING_EFFORT_DEFAULT = "default";
+var ACP_REASONING_EFFORT_NONE = "none";
 var ACP_REASONING_EFFORT_NAMES = {
   low: "Low",
   medium: "Medium",
@@ -13274,11 +14036,6 @@ var QwenAgent = class {
         cleanupErrors.push(error);
       }
     }
-    try {
-      unregisterGoalHook(session.getConfig(), sessionId);
-    } catch (error) {
-      cleanupErrors.push(error);
-    }
     try {
       this.mcpPool?.releaseSession(sessionId);
     } catch (error) {
@@ -13550,7 +14307,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.21.10";
+    const version = "0.21.11";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -13899,7 +14656,6 @@ var QwenAgent = class {
                     records: replayPage.records,
                     gaps: sessionData?.historyGaps,
                     cumulativeUsage: replayUsage,
-                    supersedeUnrestorableGoal: true,
                     logger: debugLogger8
                   });
                   replayUpdates = replay.updates;
@@ -13907,6 +14663,15 @@ var QwenAgent = class {
                     createdSession.cumulativeUsage,
                     replayUsage
                   );
+                  try {
+                    replayUpdates = replayUpdates.concat(
+                      await createdSession.renderRecoveredGoalUpdates(records)
+                    );
+                  } catch (error) {
+                    debugLogger8.debug(
+                      `Failed to render recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+                    );
+                  }
                   if (replay.replayError !== void 0) {
                     replayEnvelope = {
                       v: LOAD_REPLAY_VERSION,
@@ -13932,7 +14697,6 @@ var QwenAgent = class {
                 config,
                 createdSession
               );
-              this.#restoreGoalOnResume(config, createdSession);
             }, "beforeStartPostReplayServices")
           })
         );
@@ -14059,12 +14823,20 @@ var QwenAgent = class {
               ),
               replayHistory: false,
               beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+                try {
+                  await createdSession.publishRecoveredGoalState(
+                    config.getResumedSessionData()?.conversation.messages
+                  );
+                } catch (error) {
+                  debugLogger8.debug(
+                    `Failed to publish recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+                  );
+                }
                 await this.#restoreWorktreeOnResume(config, createdSession);
                 await this.#restoreBackgroundAgentsOnResume(
                   config,
                   createdSession
                 );
-                this.#restoreGoalOnResume(config, createdSession);
               }, "beforeStartPostReplayServices")
             }
           )
@@ -14111,48 +14883,6 @@ var QwenAgent = class {
     await config.loadPausedBackgroundAgents(config.getSessionId());
     session.pendingRecoveredAgentsNotice = config.consumePendingRecoveredAgentsNotice();
   }
-  /**
-   * Re-registers the `/goal` Stop hook when a resumed transcript ends on an
-   * unsatisfied goal — the daemon counterpart of the TUI's resume restore.
-   * Without this the goal loop silently dies whenever a session is reloaded or
-   * `qwen serve` restarts, even though the transcript still shows it as active.
-   *
-   * The `addItem` bridge that `restoreGoalFromHistory` takes in the TUI is not
-   * used here — the daemon's terminal card goes out over the wire, not into an
-   * Ink history. But restore reaches `unregisterGoalHook` on every path,
-   * including the one where there was nothing to restore, and that clears the
-   * observer the `Session` constructor installed. So it is put back afterwards,
-   * unconditionally: without it a restored goal that later achieves or fails
-   * emits no terminal update and persists no terminal card, and the next reload
-   * revives a goal that already finished.
-   *
-   * Best-effort: a failed restore must not block session load.
-   */
-  #restoreGoalOnResume(config, session) {
-    try {
-      const records = config.getResumedSessionData()?.conversation.messages;
-      if (!records?.length) return;
-      const restored = restoreGoalFromHistory(
-        collectGoalStatusItemsFromRecords(records),
-        config
-      );
-      if (restored.restored) {
-        debugLogger8.info(
-          `ACP goal restored sessionId=${config.getSessionId()} condition=${restored.condition}`
-        );
-      } else if (restored.blockedBy && restored.blockedBy !== "condition-invalid") {
-        writeStderrLineSafe(
-          `qwen: not restoring the active goal for session ${config.getSessionId()} (${restored.blockedBy}).`
-        );
-      }
-    } catch (error) {
-      writeStderrLineSafe(
-        `qwen: goal restore failed for session ${config.getSessionId()}: ${error}`
-      );
-    } finally {
-      session.installGoalTerminalObserver();
-    }
-  }
   async unstable_listSessions(params) {
     const cwd = params.cwd || process.cwd();
     const numericCursor = parseAcpSessionListCursor(params.cursor);
@@ -14233,6 +14963,29 @@ var QwenAgent = class {
         break;
       }
       case "reasoning_effort": {
+        const modelReasoning = this.getModelReasoningConfiguration(
+          session.getConfig()
+        );
+        if (modelReasoning) {
+          const selected = value === ACP_REASONING_EFFORT_NONE ? ACP_REASONING_EFFORT_NONE : modelReasoning.efforts.find((effort2) => effort2 === value);
+          if (!selected) {
+            throw RequestError.invalidParams(
+              void 0,
+              `Unknown reasoning effort: ${value}. Choose one of: ${ACP_REASONING_EFFORT_NONE}, ${modelReasoning.efforts.join(", ")}`
+            );
+          }
+          const generation = session.getConfig().getContentGeneratorConfig();
+          if (selected === ACP_REASONING_EFFORT_NONE) {
+            generation.reasoning = false;
+          } else {
+            const current = generation.reasoning;
+            generation.reasoning = {
+              ...current || {},
+              effort: selected
+            };
+          }
+          break;
+        }
         const effort = value === ACP_REASONING_EFFORT_DEFAULT ? void 0 : REASONING_EFFORT_TIERS.find((tier) => tier === value);
         if (value !== ACP_REASONING_EFFORT_DEFAULT && effort === void 0) {
           throw RequestError.invalidParams(
@@ -14268,9 +15021,14 @@ var QwenAgent = class {
     const meta = params._meta && typeof params._meta === "object" ? { ...params._meta } : {};
     const suppliedContext = meta[INVOCATION_CONTEXT_META_KEY];
     const suppliedModelPrompt = meta[DAEMON_MODEL_PROMPT_META_KEY];
+    const suppliedPromptDisplayText = meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
     delete meta[INVOCATION_CONTEXT_META_KEY];
     delete meta[DAEMON_MODEL_PROMPT_META_KEY];
     delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
+    delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
+    if (this.privateParentState === "trusted" && typeof suppliedPromptDisplayText === "string") {
+      meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] = suppliedPromptDisplayText;
+    }
     if (Object.keys(meta).length > 0) {
       sanitizedParams._meta = meta;
     } else {
@@ -18390,21 +19148,34 @@ ${outputText}
         }
         const session = this.sessionOrThrow(sessionId);
         const config = session.getConfig();
-        const cleared = unregisterGoalHook(config, sessionId);
-        if (cleared) {
-          session.emitGoalStatus({
-            kind: "cleared",
-            condition: cleared.condition,
-            iterations: cleared.iterations,
-            durationMs: Date.now() - cleared.setAt
-          });
+        let runtime;
+        try {
+          runtime = await config.getGoalRuntimeReady();
+        } catch (error) {
+          if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+          debugLogger8.info(
+            `sessionGoalClear sessionId=${sessionId} cleared=false (goal persistence unavailable)`
+          );
+          return {
+            cleared: false,
+            condition: void 0,
+            snapshot: emptyGoalSnapshot()
+          };
         }
+        const before = runtime.getSnapshot();
+        const goal = before.goal;
+        const response = goal ? await runtime.dispatch({
+          action: "clear",
+          expectedGoalId: goal.goalId,
+          expectedRevision: goal.revision
+        }) : { snapshot: before };
         debugLogger8.info(
-          `sessionGoalClear sessionId=${sessionId} cleared=${!!cleared} condition=${cleared?.condition ?? "(none)"}`
+          `sessionGoalClear sessionId=${sessionId} cleared=${!!goal} objective=${goal?.objective ?? "(none)"}`
         );
         return {
-          cleared: !!cleared,
-          condition: cleared?.condition
+          cleared: !!goal,
+          condition: goal?.objective,
+          snapshot: response.snapshot
         };
       }
       case SERVE_CONTROL_EXT_METHODS.sessionGoalGet: {
@@ -18415,16 +19186,22 @@ ${outputText}
             "Invalid or missing sessionId"
           );
         }
-        this.sessionOrThrow(sessionId);
-        const active = getActiveGoal(sessionId);
+        const session = this.sessionOrThrow(sessionId);
+        let snapshot;
+        try {
+          snapshot = (await session.getConfig().getGoalRuntimeReady()).getSnapshot();
+        } catch (error) {
+          if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+          snapshot = emptyGoalSnapshot();
+        }
+        const activeGoal = snapshot.goal?.status === "active" ? snapshot.goal : null;
         return {
-          // Projected field by field: `ActiveGoal` also carries `hookId` and
-          // `tokensAtStart`, which are this process's business.
-          active: active ? {
-            condition: active.condition,
-            iterations: active.iterations,
-            setAt: active.setAt,
-            ...active.lastReason !== void 0 ? { lastReason: active.lastReason } : {}
+          snapshot,
+          active: activeGoal ? {
+            condition: activeGoal.objective,
+            iterations: activeGoal.turnCount,
+            setAt: activeGoal.createdAt,
+            ...activeGoal.lastReason !== void 0 ? { lastReason: activeGoal.lastReason } : {}
           } : null
         };
       }
@@ -19707,6 +20484,15 @@ ${outputText}
           sessionData.conversation.messages,
           sessionData.historyGaps
         );
+        try {
+          await session.publishRecoveredGoalState(
+            sessionData.conversation.messages
+          );
+        } catch (error) {
+          debugLogger8.debug(
+            `Failed to publish recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
       }
       await options.beforeStartPostReplayServices?.(session);
       session.installRewriter();
@@ -19807,13 +20593,41 @@ ${outputText}
       currentValue: currentModelId,
       options: configModelOptions
     };
-    const reasoningEffortConfigOption = {
+    const modelReasoning = this.getModelReasoningConfiguration(config);
+    const currentModelEffort = config.getReasoningEffort?.();
+    const reasoningEffortConfigOption = modelReasoning ? {
+      id: "reasoning_effort",
+      name: "Reasoning effort",
+      description: `Thinking and reasoning effort for ${rawCurrentModelId}`,
+      category: "thought_level",
+      type: "select",
+      currentValue: config.getContentGeneratorConfig().reasoning === false ? ACP_REASONING_EFFORT_NONE : modelReasoning.efforts.find(
+        (effort) => effort === currentModelEffort
+      ) ?? modelReasoning.defaultEffort,
+      options: [
+        {
+          value: ACP_REASONING_EFFORT_NONE,
+          name: "Thinking off",
+          description: "Disable thinking for this session"
+        },
+        ...modelReasoning.efforts.map((effort) => ({
+          value: effort,
+          name: ACP_REASONING_EFFORT_NAMES[effort],
+          description: "Apply this effort to the next request"
+        }))
+      ],
+      _meta: {
+        "qwenCode/reasoning": {
+          defaultEffort: modelReasoning.defaultEffort
+        }
+      }
+    } : {
       id: "reasoning_effort",
       name: "Reasoning effort",
       description: "How hard reasoning-capable models should think",
       category: "thought_level",
       type: "select",
-      currentValue: config.getReasoningEffort?.() ?? ACP_REASONING_EFFORT_DEFAULT,
+      currentValue: currentModelEffort ?? ACP_REASONING_EFFORT_DEFAULT,
       options: [
         {
           value: ACP_REASONING_EFFORT_DEFAULT,
@@ -19829,6 +20643,14 @@ ${outputText}
     };
     return [modeConfigOption, modelConfigOption, reasoningEffortConfigOption];
   }
+  getModelReasoningConfiguration(config) {
+    if (config.getActiveRuntimeModelSnapshot?.() || config.getReasoningEffortOverride?.() || config.getContentGeneratorConfig().thinkingMandatory === true) {
+      return void 0;
+    }
+    const reasoning = getModelConfiguration(config.getModel())?.reasoning;
+    const currentEffort = config.getReasoningEffort?.();
+    return reasoning?.thinking && (!currentEffort || reasoning.efforts.includes(currentEffort)) ? reasoning : void 0;
+  }
   buildSelectableModelOptions(config) {
     const currentAuthType = config.getAuthType();
     return buildAcpModelOptions(