@qwen-code/qwen-code 0.21.10 → 0.21.11-nightly.20260814.45c2e73080

package/chunks/{acpAgent-AGS6HLQQ.js → acpAgent-MSZHQSZ7.js}

@@ -13,17 +13,17 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-NDU63YLI.js";
+} from "./chunk-GN2SCYBA.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-MIKXJYZB.js";
+} from "./chunk-WS5TWVT6.js";
 import {
   recomputeMcpGating
-} from "./chunk-4MKXUHXY.js";
+} from "./chunk-FGQY4VOZ.js";
 import {
   SessionIdConflictError,
   appEvents,
@@ -31,43 +31,47 @@ import {
   cleanupReviewWorktreeLeases,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-7GTMV7UE.js";
+} from "./chunk-6KXHEN6M.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-QG3FFJYU.js";
+} from "./chunk-NJE5NH5B.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-YWPSGJFI.js";
+} from "./chunk-4IBNVBGJ.js";
 import "./chunk-NYX53SV4.js";
-import "./chunk-NV3F44FL.js";
+import "./chunk-GNRFC5UM.js";
 import {
   collectContextData,
   formatContextUsageText
-} from "./chunk-F6WDTQ3M.js";
+} from "./chunk-BRYHERQ6.js";
 import "./chunk-4WGODMVR.js";
 import {
   startNonInteractiveOpenAILogHousekeeping
-} from "./chunk-KZ22NXBY.js";
+} from "./chunk-OT72MGHE.js";
 import "./chunk-KW7NOTN6.js";
-import "./chunk-CTJLZLB5.js";
-import "./chunk-IRZ2ZH72.js";
-import "./chunk-URKIBIFC.js";
+import "./chunk-RQS2BGPI.js";
+import "./chunk-TEFHXP7C.js";
+import {
+  isGoalStatusKind
+} from "./chunk-EKTCKZV5.js";
+import "./chunk-YYI3Z3AO.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   computeCpuPercent
 } from "./chunk-LBOVL47Y.js";
-import "./chunk-YF5MALI4.js";
+import "./chunk-IPMHLZPY.js";
 import "./chunk-6H67XLET.js";
 import {
   beginAcpBootstrapConfigProfiling,
   buildAndFreezeAcpStartupProfile,
   endAcpBootstrapConfigProfiling,
   markAcpStartup
-} from "./chunk-JT7XS4YW.js";
-import "./chunk-DCZEPFB4.js";
+} from "./chunk-ZZ7RUTJ4.js";
+import "./chunk-3XLWKV4S.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   GENERATION_TIMEOUT_MS,
+  HistoryReplayLimitError,
   MAX_REMEMBER_CONTENT_BYTES,
   REDACTED_MCP_SECRET,
   collectHistoryReplayUpdates,
@@ -86,25 +90,21 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-6LP743KE.js";
+} from "./chunk-MUTFMB5B.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-4NV6L4GZ.js";
+import "./chunk-EGB2PIYM.js";
+import "./chunk-4IWFPTAH.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
@@ -113,25 +113,25 @@ import {
   normalizeSessionIdForLookup,
   parseCallerSuppliedSessionId
 } from "./chunk-TQOF5KBL.js";
-import "./chunk-HGCQ5SE7.js";
+import "./chunk-UXEO7E3V.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-Y3OVRWRY.js";
+} from "./chunk-4QC6SUVN.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-LLCWZQCU.js";
+} from "./chunk-HM7TLULV.js";
 import {
   readVoiceModel
-} from "./chunk-EBZ6BJTF.js";
-import "./chunk-AOHJKPKL.js";
+} from "./chunk-OEVVUUYW.js";
+import "./chunk-5KZNWF2M.js";
 import "./chunk-NTTBXH7U.js";
-import "./chunk-VSFKIRRW.js";
+import "./chunk-NH6U7L42.js";
 import "./chunk-3SH53ANB.js";
 import {
   ACP_ROUTE_ID_PREFIX,
@@ -141,32 +141,32 @@ import {
   parseAcpModelOption,
   resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-2PLNY5TN.js";
+} from "./chunk-7MAHENBD.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-BGXZBI5B.js";
 import {
   resolveSkillSettings
 } from "./chunk-Z4X5MTRT.js";
-import "./chunk-NEOXOWYH.js";
-import "./chunk-UMD7WQTR.js";
+import "./chunk-6YUEAYJ5.js";
+import "./chunk-5XNR53C7.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-LHEC5V6G.js";
-import "./chunk-67EWJE77.js";
-import "./chunk-E2FPSSKP.js";
+import "./chunk-AXEL55JW.js";
+import "./chunk-XY7DGTIC.js";
+import "./chunk-KZKEVWJW.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-4WL6SY4F.js";
+} from "./chunk-WDSTNDEW.js";
 import {
   SESSION_SOURCE_META_KEY,
   parseSessionSource
-} from "./chunk-F24A2JBM.js";
-import "./chunk-MZSJ43WV.js";
-import "./chunk-XCGIMOLN.js";
+} from "./chunk-CUXI3S6E.js";
+import "./chunk-W5ZFJYUG.js";
+import "./chunk-WCCLLK7X.js";
 import "./chunk-OCPBI7J5.js";
 import {
   ndJsonStream
-} from "./chunk-I5VM3SKY.js";
+} from "./chunk-OMVHZ7E6.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -174,8 +174,8 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-DA4HRSBW.js";
-import "./chunk-VKJ4KTPJ.js";
+} from "./chunk-NHZF4VCD.js";
+import "./chunk-U7ROFHSH.js";
 import "./chunk-V6WHFGST.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
@@ -188,8 +188,11 @@ 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_MAX_BYTES,
+  LOAD_REPLAY_MAX_UPDATES,
   LOAD_REPLAY_META_KEY,
   LOAD_REPLAY_MODE_META_KEY,
   LOAD_REPLAY_PAGE_SIZE_META_KEY,
@@ -202,7 +205,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-W5UC37EE.js";
+} from "./chunk-UFHPAMAV.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError
@@ -210,7 +213,7 @@ import {
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-YP5KH5Y7.js";
-import "./chunk-PBRVUF5B.js";
+import "./chunk-JW5UEE3V.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-HIBNSEJE.js";
 import "./chunk-M5GB774H.js";
@@ -221,20 +224,20 @@ import {
   PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
   isValidExternalToolGuardDenialReason
 } from "./chunk-BKHCW2BI.js";
-import "./chunk-UVX4Y6IN.js";
+import "./chunk-7JL5YBSA.js";
 import {
   ACP_EVENT_LOOP_STALL_RESTART_MS,
   CHANNEL_PROMPT_META_KEY
-} from "./chunk-DX3RGJMS.js";
+} from "./chunk-ADJDLEVO.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
-} from "./chunk-UDXSXLER.js";
+} from "./chunk-IW6RQPQB.js";
 import {
   assembleMcpServers,
   loadMcpApprovals
-} from "./chunk-KID7K6H2.js";
+} from "./chunk-SNPOURNX.js";
 import {
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
@@ -243,8 +246,8 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-ABVRJU3D.js";
-import "./chunk-UBX6NL47.js";
+} from "./chunk-LY2SB7GC.js";
+import "./chunk-JLT5HCGQ.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -254,7 +257,7 @@ import {
 import {
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-UEOKWYGY.js";
+} from "./chunk-SESSAEWC.js";
 import {
   SUPPORTED_LANGUAGES
 } from "./chunk-5EJZE3FP.js";
@@ -262,18 +265,18 @@ import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-ZJ4W6SUY.js";
+} from "./chunk-L6PE52MF.js";
 import {
   ENV_ACP_REPEATED_TOOL_FAILURE_GUARD
-} from "./chunk-VFMASYQA.js";
-import "./chunk-Q3AL4JQ3.js";
-import "./chunk-AEL7KN2O.js";
-import "./chunk-VJNBRRZG.js";
+} from "./chunk-MS7GNABG.js";
+import "./chunk-IAE7LYSB.js";
+import "./chunk-DANYMI4U.js";
+import "./chunk-WZMH7II3.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-GWVUR3QZ.js";
+} from "./chunk-ZM6LZON7.js";
 import "./chunk-NPQ5ZKRP.js";
 import "./chunk-MR3PXB6E.js";
 import "./chunk-XFSFZCM5.js";
@@ -326,7 +329,7 @@ import {
   buildPermissionCheckContext,
   buildSessionRecoveryPlanFromApiHistory,
   clampInlineMediaPart,
-  clearGoalTerminalObserver,
+  collectSessionTurnState,
   computeUniqueBranchTitle,
   convertToFunctionErrorResponse,
   convertToFunctionResponse,
@@ -343,7 +346,6 @@ import {
   evaluatePlanModeShellPolicy,
   evaluateToolInvocationGuard,
   finalizeToolResponses,
-  findBoundaryAtOrBefore,
   findExistingProviderModels,
   findPlanModeEntryBatchBoundaryIndex,
   findProviderById,
@@ -376,7 +378,6 @@ import {
   isDenialFallbackReason,
   isGatedMcpScope,
   isPlanModeBlocked,
-  isReplayTurnStartType,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
   mcpServerRequiresOAuth,
@@ -384,6 +385,7 @@ import {
   normalizeEventPayload,
   normalizeSnapshotPayload,
   persistPermissionOutcome,
+  projectGoalStateToLegacy,
   readManyFiles,
   recordAllow,
   recordFallbackApprove,
@@ -395,8 +397,6 @@ import {
   runForkedAgent,
   runManagedAutoMemoryDream,
   runManagedRememberByAgent,
-  sessionIdContext,
-  setGoalTerminalObserver,
   shouldClassifyAllShellForAutoMode,
   shouldFallback,
   shouldFirePermissionDeniedForAutoMode,
@@ -404,29 +404,29 @@ import {
   shouldHaltOnTurnToolCallCap,
   shouldRunAutoModeForCall,
   subagentGenerator,
-  unregisterGoalHook,
+  truncateNotificationLabel,
   updateSetting,
   validatePlanModeShellApproval,
   validatePlanModeShellContext
-} from "./chunk-EI3NWELG.js";
+} from "./chunk-WH32GXQS.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-NM33GGOM.js";
+import "./chunk-A4BAHMJF.js";
+import "./chunk-ZPZANKVP.js";
+import "./chunk-A6GQUQ7I.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-TRRF5BSP.js";
+import "./chunk-F4BUGC4Y.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-GNPNYXJB.js";
-import "./chunk-HUWENAHO.js";
+import "./chunk-AAZWJAPQ.js";
+import "./chunk-7WUMS2UA.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -434,53 +434,60 @@ import {
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-J6SZID63.js";
+import "./chunk-KTWUFHS4.js";
 import "./chunk-KRXPRVGL.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-GM463R2B.js";
-import "./chunk-SEZ556DZ.js";
-import "./chunk-2FRY5CRX.js";
+} from "./chunk-2ASWIM4A.js";
+import "./chunk-67F2BEYW.js";
+import "./chunk-TNETSI2A.js";
 import {
+  GoalPersistenceUnavailableError,
+  emptyGoalSnapshot,
+  goalTurnContext,
+  parseGoalSnapshotV2,
+  parseGoalStateCause,
   wrapUserPromptSubmitContext
-} from "./chunk-QUI267ZP.js";
+} from "./chunk-B66LYK4B.js";
 import {
   APPROVAL_MODES
-} from "./chunk-WAUGQKUU.js";
-import "./chunk-DZUO626D.js";
+} from "./chunk-SNHBRO4C.js";
+import "./chunk-OUCCIS3E.js";
 import {
+  addDaemonRequestAttribute,
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
   extractDaemonTraceContext,
   registerAcpEventLoopLagGauge,
   startEventLoopLagMonitor,
   withDaemonSpan
-} from "./chunk-4TRQPFDP.js";
+} from "./chunk-U3O2EO5Y.js";
 import "./chunk-SAH4BD2J.js";
+import "./chunk-66PLFJQ7.js";
 import {
   runWithRuntimeContentGenerator
-} from "./chunk-CPG6P4GG.js";
+} from "./chunk-SKRHR6N2.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-2J3OJGTL.js";
 import {
   FORK_SUBAGENT_TYPE,
   getStartupContextLength,
   isSystemReminderContent
-} from "./chunk-IA7TGCN2.js";
+} from "./chunk-TROB4PZY.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-EQL65XGA.js";
+import "./chunk-UHF5VBKO.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-3P2LV43B.js";
+} from "./chunk-MMEDZKWK.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-HV76SFIA.js";
-import "./chunk-4PYCZH2V.js";
+import "./chunk-YI5G32RU.js";
+import "./chunk-QEWAHAW2.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-SR7RZ4MS.js";
-import "./chunk-M6HMMKVG.js";
+import "./chunk-FTGU6G45.js";
+import "./chunk-PSTHNTHF.js";
 import {
   REASONING_EFFORT_TIERS,
   applyReasoningEffort
@@ -491,7 +498,7 @@ import {
   getToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-EI3HZX6C.js";
+import "./chunk-KK3FEHPJ.js";
 import {
   ConversationFinishedEvent,
   DiscoveredMCPTool,
@@ -502,6 +509,7 @@ import {
   PromptSuggestionEvent,
   RepeatedToolFailureGuardEvent,
   UserPromptEvent,
+  apiActivityTracker,
   formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
@@ -523,17 +531,17 @@ import {
   shouldRunVisionBridge,
   splitImageParts,
   uiTelemetryService
-} from "./chunk-YGT2AUJ7.js";
-import "./chunk-WOJZWRAZ.js";
+} from "./chunk-LAKFZU36.js";
+import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-FVKHVJZQ.js";
+} from "./chunk-6OJDN5ZT.js";
 import {
   runSideQuery
-} from "./chunk-COBO5EBO.js";
-import "./chunk-6ZRFAKXK.js";
+} from "./chunk-JRTJEGSP.js";
+import "./chunk-C2DR57L6.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -541,20 +549,20 @@ import {
   ToolNames,
   canonicalToolName,
   isShellProgressData
-} from "./chunk-PYQADEFD.js";
+} from "./chunk-ZRT36RSF.js";
 import {
   AuthType,
   preloadContentGenerator
-} from "./chunk-Y4R47ZUH.js";
+} from "./chunk-RTBUTKAX.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-H6BFLALJ.js";
+import "./chunk-O6SLWH4X.js";
+import "./chunk-NW7SPXVG.js";
 import {
   endToolExecutionSpan,
   endToolSpan,
@@ -563,21 +571,23 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   withInteractionSpan
-} from "./chunk-L2AFWWJE.js";
-import "./chunk-W4RQUHY3.js";
-import "./chunk-PDPFQ2FO.js";
+} from "./chunk-7UNST76G.js";
+import "./chunk-HHJLM3WQ.js";
+import {
+  sessionIdContext
+} from "./chunk-K5IDV3PC.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-OIVKILPI.js";
+} from "./chunk-YMB77M76.js";
 import "./chunk-VOQXFAY5.js";
-import "./chunk-AQAJJMRR.js";
+import "./chunk-YPITLFHS.js";
 import {
   runExitCleanup
-} from "./chunk-AAE6SR4Q.js";
+} from "./chunk-DX7V233D.js";
 import {
   writeStderrLine,
   writeStderrLineSafe
@@ -1424,6 +1434,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 +1587,261 @@ 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, goalState) {
+    const update = buildGoalStatusUpdate(status);
+    if (goalState) {
+      update._meta = { ...update._meta, goalState };
+    }
+    await this.sendUpdate(update);
+  }
+  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/recovered-goal-update.ts
+init_esbuild_shims();
+async function renderPreparedGoalUpdate(getRuntime, options = {}) {
+  let runtime;
+  try {
+    runtime = await getRuntime();
+  } catch (error) {
+    if (!(error instanceof GoalPersistenceUnavailableError)) throw error;
+    const status = unrestorableGoalStatus(
+      options.replayedRecords,
+      options.bootstrap
+    );
+    return { updates: status ? [buildGoalStatusUpdate(status)] : [] };
+  }
+  const cause = runtime.getRecoveryCause?.();
+  if (!cause) return { updates: [] };
+  const snapshot = runtime.getSnapshot();
+  const publicationKey = goalPublicationKey(snapshot, cause);
+  if (options.hideRuntimeGoal) {
+    return {
+      publicationKey,
+      ...snapshot.goal ? {
+        suppressedGoalId: snapshot.goal.goalId
+      } : {},
+      updates: []
+    };
+  }
+  const bootstrapGoal = options.bootstrap?.goalState?.goal;
+  const bootstrapMatchesRuntime = bootstrapGoal != null && snapshot.goal?.goalId === bootstrapGoal.goalId && snapshot.goal?.revision === bootstrapGoal.revision;
+  return {
+    publicationKey,
+    updates: options.bootstrap && bootstrapMatchesRuntime ? [] : [buildGoalStateUpdate(snapshot, cause, options.previousGoal ?? null)]
+  };
+}
+__name(renderPreparedGoalUpdate, "renderPreparedGoalUpdate");
+function unrestorableGoalStatus(replayedRecords, bootstrap) {
+  const active = (replayedRecords?.length ? findGoalToRestore(collectGoalStatusItemsFromRecords(replayedRecords)) : void 0) ?? bootstrap?.goalStatus;
+  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."
+  };
+}
+__name(unrestorableGoalStatus, "unrestorableGoalStatus");
+function goalPublicationKey(snapshot, cause) {
+  return cause ? `${cause}:${JSON.stringify(snapshot)}` : void 0;
+}
+__name(goalPublicationKey, "goalPublicationKey");
+
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
 
@@ -2678,6 +3023,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 +3071,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.";
@@ -3136,28 +3537,6 @@ function resolveHomeLoopResolverRoots({
   };
 }
 __name(resolveHomeLoopResolverRoots, "resolveHomeLoopResolverRoots");
-function computeInitialTurnFromHistory(records, sessionId) {
-  let maxPromptTurn = 0;
-  let userMessageCount = 0;
-  const promptIdPrefix = `${sessionId}########`;
-  for (const record of records) {
-    if (record.sessionId === sessionId && isUserPromptRecord(record)) {
-      userMessageCount += 1;
-    }
-    for (const promptId of getRecordPromptIds(record)) {
-      if (!promptId.startsWith(promptIdPrefix)) {
-        continue;
-      }
-      const suffix = promptId.slice(promptIdPrefix.length);
-      if (!/^\d+$/.test(suffix)) {
-        continue;
-      }
-      maxPromptTurn = Math.max(maxPromptTurn, Number(suffix));
-    }
-  }
-  return maxPromptTurn > 0 ? maxPromptTurn : userMessageCount;
-}
-__name(computeInitialTurnFromHistory, "computeInitialTurnFromHistory");
 async function fireSessionPermissionDeniedForAutoMode(config, decision, outcome, toolName, toolParams, callId, signal) {
   if (!config.getDisableAllHooks?.() && shouldFirePermissionDeniedForAutoMode(decision, outcome)) {
     try {
@@ -3177,40 +3556,6 @@ async function fireSessionPermissionDeniedForAutoMode(config, decision, outcome,
   }
 }
 __name(fireSessionPermissionDeniedForAutoMode, "fireSessionPermissionDeniedForAutoMode");
-function getRecordPromptIds(record) {
-  const promptIds = [];
-  const recordPromptId = record.promptId;
-  if (typeof recordPromptId === "string") {
-    promptIds.push(recordPromptId);
-  }
-  const telemetryPromptId = readTelemetryPromptId(record.systemPayload);
-  if (telemetryPromptId) {
-    promptIds.push(telemetryPromptId);
-  }
-  return promptIds;
-}
-__name(getRecordPromptIds, "getRecordPromptIds");
-function readTelemetryPromptId(payload) {
-  if (!payload || typeof payload !== "object" || !("uiEvent" in payload)) {
-    return void 0;
-  }
-  const uiEvent = payload.uiEvent;
-  if (!uiEvent || typeof uiEvent !== "object" || !("prompt_id" in uiEvent)) {
-    return void 0;
-  }
-  const promptId = uiEvent.prompt_id;
-  return typeof promptId === "string" ? promptId : void 0;
-}
-__name(readTelemetryPromptId, "readTelemetryPromptId");
-function isUserPromptRecord(record) {
-  if (record.type !== "user" || record.subtype === "realtime_message") {
-    return false;
-  }
-  return record.message?.parts?.some(
-    (part) => typeof part.text === "string" && part.text.trim().length > 0
-  ) ?? false;
-}
-__name(isUserPromptRecord, "isUserPromptRecord");
 var AT_TOKEN_RE = /@([^\s,;!?()[\]{}]+)/g;
 function collectExtensionMentionRefs(text, mentions) {
   for (const match of text.matchAll(AT_TOKEN_RE)) {
@@ -3346,11 +3691,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 +3781,17 @@ var Session = class {
   persistedBackgroundNotificationTaskIds = /* @__PURE__ */ new Set();
   backgroundNotificationAcceptances = /* @__PURE__ */ new Map();
   activeAgentNotificationAcceptances = /* @__PURE__ */ new Set();
+  goalQueue = [];
+  goalProcessing = false;
+  activeGoalTurn;
+  goalHostUnbind;
+  goalRuntimeUnsubscribe;
+  lastGoalSnapshot;
+  lastGoalPublicationKey;
+  // Set only when runtime recovery selected a Goal that initial replay hid.
+  // Keep that Goal private through activation and later progress updates.
+  suppressedRecoveredGoalId;
+  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 +3837,296 @@ 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.suppressedRecoveredGoalId = 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);
+  }
+  async renderRecoveredGoalUpdates(replayedRecords) {
+    if (this.disposed || this.closing) return [];
+    const rendered = await renderPreparedGoalUpdate(
+      () => this.config.getGoalRuntimeReady(),
+      {
+        ...replayedRecords ? { replayedRecords } : {},
+        previousGoal: this.lastGoalSnapshot?.goal ?? null
+      }
+    );
+    if (rendered.publicationKey && rendered.publicationKey === this.lastGoalPublicationKey) {
+      return [];
+    }
+    this.primeRecoveredGoalPublication(rendered.publicationKey);
+    return rendered.updates;
+  }
+  primeRecoveredGoalPublication(publicationKey, suppressedGoalId) {
+    if (publicationKey) this.lastGoalPublicationKey = publicationKey;
+    this.suppressedRecoveredGoalId = suppressedGoalId;
+  }
+  #suppressRecoveredGoalUpdate(snapshot) {
+    const suppressedGoalId = this.suppressedRecoveredGoalId;
+    if (!suppressedGoalId) return false;
+    const goal = snapshot.goal;
+    if (goal?.goalId === suppressedGoalId) return true;
+    if (goal === null) {
+      this.suppressedRecoveredGoalId = void 0;
+      return true;
+    }
+    this.suppressedRecoveredGoalId = void 0;
+    return false;
+  }
+  /**
+   * 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."
+    };
+  }
+  async #publishGoalState(snapshot, cause, previousGoal = this.lastGoalSnapshot?.goal ?? null) {
+    if (this.#suppressRecoveredGoalUpdate(snapshot)) return;
+    const publicationKey = 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 +4780,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 +4808,7 @@ var Session = class {
       resolveGate();
       if (this.disposed) return;
       this.closing = false;
+      void this.#drainGoalQueue();
       void this.#drainCronQueue();
       void this.#drainNotificationQueue();
     };
@@ -4227,6 +4872,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 +4907,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,64 +4923,30 @@ 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.
    */
   primeTurnFromHistory(records) {
-    for (const record of records) {
-      if (record.subtype !== "notification") continue;
-      const backgroundTask = record.systemPayload?.backgroundTask;
-      if (typeof backgroundTask?.taskId === "string") {
-        this.persistedBackgroundNotificationTaskIds.add(backgroundTask.taskId);
-      }
-    }
-    this.turn = Math.max(
-      this.turn,
-      computeInitialTurnFromHistory(records, this.config.getSessionId())
+    const turnState = collectSessionTurnState(
+      records,
+      this.config.getSessionId()
     );
+    this.primeTurnState(
+      turnState.initialTurn,
+      turnState.backgroundNotificationTaskIds
+    );
+  }
+  primeTurnState(initialTurn, backgroundNotificationTaskIds) {
+    for (const taskId of backgroundNotificationTaskIds) {
+      this.persistedBackgroundNotificationTaskIds.add(taskId);
+    }
+    this.turn = Math.max(this.turn, initialTurn);
   }
-  async replayHistory(records, gaps) {
+  async replayHistory(records, gaps, options) {
     this.primeTurnFromHistory(records);
     try {
-      await this.historyReplayer.replay(records, gaps);
+      await this.historyReplayer.replay(records, gaps, options);
     } finally {
       this.activeTodoPlanRevision = void 0;
     }
@@ -4446,11 +5064,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 +5078,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 +5093,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 +5123,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 +5150,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 +5220,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 +5276,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 +5306,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 +5324,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 +5454,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 +5462,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 +5470,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 +5502,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 +5518,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 +5549,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 +5593,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 +5619,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 +5734,7 @@ ${this.pendingRecoveredAgentsNotice}
                 );
                 let channelDeliveryResponseBlock;
                 try {
+                  if (goalTurn) goalTurn.modelStarted = true;
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
                     nextMessage?.parts ?? [],
@@ -5404,11 +6143,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 +6890,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 +7379,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 +7391,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 +7412,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 +7782,7 @@ ${this.pendingRecoveredAgentsNotice}
     backgroundRegistry.setStatusChangeCallback(this.#statusChangeCallback);
     backgroundRegistry.setNotificationCallback(
       (displayText, modelText, meta) => {
+        const entry = backgroundRegistry.get(meta.agentId);
         this.#enqueueBackgroundNotification({
           displayText,
           modelText,
@@ -7047,7 +7791,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 +7805,7 @@ ${this.pendingRecoveredAgentsNotice}
       if (meta.status === "running") {
         return;
       }
+      const entry = monitorRegistry.get(meta.monitorId);
       this.#enqueueBackgroundNotification({
         displayText,
         modelText,
@@ -7067,11 +7817,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 +7835,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 +7927,8 @@ ${this.pendingRecoveredAgentsNotice}
           taskId: item.taskId,
           status: item.status,
           kind: item.kind,
-          toolUseId: item.toolUseId
+          toolUseId: item.toolUseId,
+          ...item.structured
         }
       );
     } catch (error) {
@@ -7193,7 +7951,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 +7965,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 +7976,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 +8003,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 +8042,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 +8259,8 @@ ${this.pendingRecoveredAgentsNotice}
           taskId: item.taskId,
           status: item.status,
           kind: item.kind,
-          toolUseId: item.toolUseId
+          toolUseId: item.toolUseId,
+          ...item.structured
         }
       }
     });
@@ -9721,30 +10482,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 +10499,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 +10549,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 +11104,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 +11257,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",
@@ -10707,29 +11466,185 @@ function parseSessionArtifactBasePayload(payload, expectedSessionId) {
   if (!isObjectRecord(payload)) {
     throw invalidArtifactPersistPayload();
   }
-  if (payload["v"] !== SESSION_ARTIFACT_PERSISTENCE_VERSION || payload["sessionId"] !== expectedSessionId || !Number.isSafeInteger(payload["sequence"]) || payload["sequence"] < 0 || typeof payload["recordedAt"] !== "string" || payload["recordedAt"].length === 0) {
-    throw invalidArtifactPersistPayload();
+  if (payload["v"] !== SESSION_ARTIFACT_PERSISTENCE_VERSION || payload["sessionId"] !== expectedSessionId || !Number.isSafeInteger(payload["sequence"]) || payload["sequence"] < 0 || typeof payload["recordedAt"] !== "string" || payload["recordedAt"].length === 0) {
+    throw invalidArtifactPersistPayload();
+  }
+  return payload;
+}
+__name(parseSessionArtifactBasePayload, "parseSessionArtifactBasePayload");
+function invalidArtifactPersistPayload() {
+  return RequestError.invalidParams(
+    void 0,
+    "Invalid or missing artifact persist payload"
+  );
+}
+__name(invalidArtifactPersistPayload, "invalidArtifactPersistPayload");
+function isBulkLoadReplayRequest(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
+}
+__name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
+function shouldHideInheritedHistory(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  return meta?.[LOAD_REPLAY_HIDE_INHERITED_META_KEY] === true;
+}
+__name(shouldHideInheritedHistory, "shouldHideInheritedHistory");
+function loadRestoreOptions(params) {
+  const hideInheritedHistory = shouldHideInheritedHistory(params);
+  if (!isBulkLoadReplayRequest(params)) {
+    return { replay: { kind: "all", hideInheritedHistory } };
+  }
+  const limit = getLoadReplayPageSize(params);
+  return limit === void 0 ? { replay: { kind: "all", hideInheritedHistory } } : { replay: { kind: "recent", limit, hideInheritedHistory } };
+}
+__name(loadRestoreOptions, "loadRestoreOptions");
+var RESUME_RESTORE_OPTIONS = {
+  replay: { kind: "none" }
+};
+function mapSessionRestoreRequestError(error, sessionId) {
+  const mappedWriterError = mapSessionWriterRequestError(error);
+  if (mappedWriterError !== error) return mappedWriterError;
+  if (error instanceof SessionTranscriptSnapshotUnavailableError) {
+    return new RequestError(-32010, error.message, {
+      errorKind: "transcript_snapshot_unavailable",
+      sessionId
+    });
+  }
+  if (error instanceof SessionTranscriptTooLargeError) {
+    return new RequestError(-32011, error.message, {
+      errorKind: "transcript_too_large",
+      sessionId,
+      snapshotSize: error.snapshotSize,
+      maxBytes: error.maxBytes
+    });
+  }
+  if (error instanceof SessionTranscriptPageTooLargeError) {
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.envelope_limit_reason",
+      "bytes"
+    );
+    return new RequestError(-32012, error.message, {
+      errorKind: "transcript_page_too_large",
+      sessionId,
+      pageBytes: error.pageBytes,
+      maxBytes: error.maxBytes
+    });
+  }
+  if (error instanceof HistoryReplayLimitError) {
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.envelope_limit_reason",
+      error.reason
+    );
+    return new RequestError(-32012, error.message, {
+      errorKind: "transcript_page_too_large",
+      sessionId,
+      reason: error.reason,
+      observed: error.observed,
+      limit: error.limit
+    });
+  }
+  return error;
+}
+__name(mapSessionRestoreRequestError, "mapSessionRestoreRequestError");
+function validateLoadReplayEnvelope(sessionId, envelope, enforceLimits) {
+  if (!enforceLimits) return;
+  if (envelope.updates.length > LOAD_REPLAY_MAX_UPDATES) {
+    throw new HistoryReplayLimitError(
+      sessionId,
+      "updates",
+      envelope.updates.length,
+      LOAD_REPLAY_MAX_UPDATES
+    );
+  }
+  const pageBytes = Buffer.byteLength(JSON.stringify(envelope), "utf8");
+  if (pageBytes > LOAD_REPLAY_MAX_BYTES) {
+    throw new HistoryReplayLimitError(
+      sessionId,
+      "bytes",
+      pageBytes,
+      LOAD_REPLAY_MAX_BYTES
+    );
+  }
+}
+__name(validateLoadReplayEnvelope, "validateLoadReplayEnvelope");
+function replayGoalBootstrap(projection) {
+  if (projection && !("runtime" in projection)) {
+    const sourceUuid2 = projection.goalRecoverySourceUuid;
+    if (!sourceUuid2) return void 0;
+    if (projection.replay?.records.some((record) => record.uuid === sourceUuid2)) {
+      return void 0;
+    }
+    const replay = projection.replay?.replay;
+    if (isObjectRecord(replay)) {
+      const bootstrap = HistoryReplayer.v2GoalBootstrap(
+        replay["goalState"],
+        replay["goalCause"]
+      );
+      if (bootstrap) return bootstrap;
+    }
+    const sourceRecord2 = projection.goalRecords?.find(
+      (record) => record.uuid === sourceUuid2
+    );
+    if (sourceRecord2?.subtype === "goal_state") {
+      const payload = isObjectRecord(sourceRecord2.systemPayload) ? sourceRecord2.systemPayload : void 0;
+      return HistoryReplayer.v2GoalBootstrap(
+        payload?.["snapshot"],
+        payload?.["cause"]
+      );
+    }
+    const active2 = findGoalToRestore(
+      collectGoalStatusItemsFromRecords(projection.goalRecords ?? [])
+    );
+    return active2 ? {
+      goalStatus: {
+        kind: active2.iterations > 0 ? "checking" : "set",
+        condition: active2.condition,
+        iterations: active2.iterations,
+        ...active2.setAt !== void 0 ? { setAt: active2.setAt } : {}
+      }
+    } : void 0;
+  }
+  const sourceUuid = projection?.replay?.goalRecoverySourceUuid;
+  if (!projection?.replay || !sourceUuid) return void 0;
+  if (projection.replay.records.some((record) => record.uuid === sourceUuid)) {
+    return void 0;
   }
-  return payload;
-}
-__name(parseSessionArtifactBasePayload, "parseSessionArtifactBasePayload");
-function invalidArtifactPersistPayload() {
-  return RequestError.invalidParams(
-    void 0,
-    "Invalid or missing artifact persist payload"
+  const goalBootstrapRecords = projection.replay.goalBootstrapRecords ?? [];
+  const sourceRecord = goalBootstrapRecords.find(
+    (record) => record.uuid === sourceUuid
   );
+  if (sourceRecord?.subtype === "goal_state") {
+    const payload = isObjectRecord(sourceRecord.systemPayload) ? sourceRecord.systemPayload : void 0;
+    return HistoryReplayer.v2GoalBootstrap(
+      payload?.["snapshot"],
+      payload?.["cause"]
+    );
+  }
+  const active = findGoalToRestore(
+    collectGoalStatusItemsFromRecords(goalBootstrapRecords)
+  );
+  if (!active) return void 0;
+  return {
+    goalStatus: {
+      kind: active.iterations > 0 ? "checking" : "set",
+      condition: active.condition,
+      iterations: active.iterations,
+      ...active.setAt !== void 0 ? { setAt: active.setAt } : {}
+    }
+  };
 }
-__name(invalidArtifactPersistPayload, "invalidArtifactPersistPayload");
-function isBulkLoadReplayRequest(params) {
-  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
-  return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
-}
-__name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
-function shouldHideInheritedHistory(params) {
-  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
-  return meta?.[LOAD_REPLAY_HIDE_INHERITED_META_KEY] === true;
+__name(replayGoalBootstrap, "replayGoalBootstrap");
+function replayInitialGoalState(projection) {
+  const replay = projection?.replay?.replay;
+  if (!isObjectRecord(replay)) return {};
+  const initialGoalState = parseGoalSnapshotV2(replay["goalState"]);
+  const initialGoalCause = parseGoalStateCause(replay["goalCause"]);
+  return {
+    ...initialGoalState ? { initialGoalState } : {},
+    ...initialGoalCause ? { initialGoalCause } : {}
+  };
 }
-__name(shouldHideInheritedHistory, "shouldHideInheritedHistory");
+__name(replayInitialGoalState, "replayInitialGoalState");
 function selectVisibleHistoryRecords(records, hideInheritedHistory) {
   const sourceBoundary = records.findIndex(
     (record) => record.type === "system" && record.subtype === "session_source" && isObjectRecord(record.systemPayload) && record.systemPayload["sourceType"] === "side_task"
@@ -10770,61 +11685,6 @@ function getLoadReplayPageSize(params) {
   return value;
 }
 __name(getLoadReplayPageSize, "getLoadReplayPageSize");
-function isHistoryTurnStart(record) {
-  return isReplayTurnStartType(record.type, record.subtype);
-}
-__name(isHistoryTurnStart, "isHistoryTurnStart");
-function isHistoryPageStart(record) {
-  return record.subtype !== "realtime_message" && (record.type === "assistant" || isHistoryTurnStart(record));
-}
-__name(isHistoryPageStart, "isHistoryPageStart");
-function historyOrphansToolResult(records, start, end) {
-  for (let i = start; i < end; i++) {
-    if (records[i].type !== "tool_result") continue;
-    for (let owner = i - 1; owner >= start; owner--) {
-      if (isHistoryPageStart(records[owner])) return false;
-    }
-    return true;
-  }
-  return false;
-}
-__name(historyOrphansToolResult, "historyOrphansToolResult");
-function selectRecentHistoryRecords(records, pageSize) {
-  if (pageSize === void 0 || records.length <= pageSize) {
-    return { records, hasMore: false };
-  }
-  let start = records.length - pageSize;
-  for (let i = start; i < records.length; i++) {
-    if (isHistoryTurnStart(records[i])) {
-      start = i;
-      break;
-    }
-  }
-  const expansionFloor = Math.max(0, records.length - 2 * pageSize);
-  const aligned = findBoundaryAtOrBefore(
-    records,
-    start,
-    expansionFloor,
-    isHistoryTurnStart
-  );
-  if (isHistoryTurnStart(records[aligned])) {
-    start = aligned;
-  }
-  if (start > 0 && historyOrphansToolResult(records, start, records.length)) {
-    const pairFloor = Math.max(0, start - pageSize);
-    const owner = findBoundaryAtOrBefore(
-      records,
-      start,
-      pairFloor,
-      isHistoryPageStart
-    );
-    if (isHistoryPageStart(records[owner])) {
-      start = owner;
-    }
-  }
-  return { records: records.slice(start), hasMore: start > 0 };
-}
-__name(selectRecentHistoryRecords, "selectRecentHistoryRecords");
 function createHiddenWorkspaceMemoryConfig(config) {
   return new Proxy(config, {
     get(target, prop) {
@@ -13274,11 +14134,6 @@ var QwenAgent = class {
         cleanupErrors.push(error);
       }
     }
-    try {
-      unregisterGoalHook(session.getConfig(), sessionId);
-    } catch (error) {
-      cleanupErrors.push(error);
-    }
     try {
       this.mcpPool?.releaseSession(sessionId);
     } catch (error) {
@@ -13299,7 +14154,7 @@ var QwenAgent = class {
       );
     }
   }
-  async withLiveSessionRestore(sessionId, session, operation) {
+  async withLiveSessionRestore(sessionId, session, options, operation) {
     await session.assertCanStartTurn();
     const config = session.getConfig();
     const releaseGate = session.beginClose();
@@ -13310,12 +14165,12 @@ var QwenAgent = class {
         "restore"
       );
       const recorder = config.getChatRecordingService();
-      const loadAuthoritative = /* @__PURE__ */ __name(() => config.getSessionService().loadSession(sessionId), "loadAuthoritative");
-      const data = recorder ? await recorder.runWithWriteBarrier(loadAuthoritative) : await loadAuthoritative();
-      if (!data) throw new SessionWriterUnavailableError();
-      return await operation(config, data);
+      const readProjection = /* @__PURE__ */ __name(() => config.getSessionService().readLiveRestoreProjection(sessionId, options), "readProjection");
+      const projection = recorder ? await recorder.runWithWriteBarrier(readProjection) : await readProjection();
+      if (!projection) throw new SessionWriterUnavailableError();
+      return await operation(config, projection);
     } catch (error) {
-      throw mapSessionWriterRequestError(error);
+      throw mapSessionRestoreRequestError(error, sessionId);
     } finally {
       releaseGate();
     }
@@ -13342,7 +14197,7 @@ var QwenAgent = class {
       this.pendingConfigCleanup.delete(cleanupKey);
     }
   }
-  async cleanupAfterRequestFailure(error, cleanup) {
+  async cleanupAfterRequestFailure(error, cleanup, sessionId) {
     try {
       await cleanup();
     } catch (cleanupError) {
@@ -13350,7 +14205,7 @@ var QwenAgent = class {
         `Session cleanup failed while preserving the original request error: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
       );
     }
-    throw mapSessionWriterRequestError(error);
+    throw sessionId ? mapSessionRestoreRequestError(error, sessionId) : mapSessionWriterRequestError(error);
   }
   pendingConfigCleanupKey(runtimeBaseDir, sessionId) {
     return `${path4.resolve(runtimeBaseDir)}\0${sessionId}`;
@@ -13550,7 +14405,7 @@ var QwenAgent = class {
     }
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.21.10";
+    const version = "0.21.11-nightly.20260814.45c2e73080";
     const response = {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -13751,6 +14606,7 @@ var QwenAgent = class {
   async loadSessionWithProfiler(params, initialSessionId, profiler) {
     let sessionId = initialSessionId;
     const sessionSource = getSessionSource(params);
+    const restoreOptions = loadRestoreOptions(params);
     const liveSession = this.sessions.get(sessionId);
     if (liveSession) {
       const settings = profiler.timeSync(
@@ -13763,35 +14619,43 @@ var QwenAgent = class {
         return this.withLiveSessionRestore(
           sessionId,
           liveSession,
-          async (config, sessionData) => {
+          restoreOptions,
+          async (config, projection) => {
             const response = profiler.timeSync(
               "response_build",
               () => ({
                 modes: this.buildModesData(config),
                 models: this.buildAvailableModels(config),
                 configOptions: this.buildConfigOptions(config),
-                ...sessionData.artifactSnapshot ? { artifactSnapshot: sessionData.artifactSnapshot } : {}
+                ...projection?.artifactSnapshot ? { artifactSnapshot: projection.artifactSnapshot } : {}
               })
             );
-            const records = sessionData.conversation.messages;
-            const visibleRecords = selectVisibleHistoryRecords(
-              records,
-              shouldHideInheritedHistory(params)
-            );
-            if (visibleRecords.length === 0) return response;
+            const replayPage = projection?.replay;
+            if (!replayPage || replayPage.records.length === 0) return response;
             const bulkReplay = isBulkLoadReplayRequest(params);
-            const replayPage = bulkReplay ? selectRecentHistoryRecords(
-              visibleRecords,
-              getLoadReplayPageSize(params)
-            ) : { records: visibleRecords, hasMore: false };
-            const replay = await collectHistoryReplayUpdates({
-              sessionId,
-              config,
-              records: replayPage.records,
-              gaps: sessionData.historyGaps,
-              cumulativeUsage: createReplayCumulativeUsage(),
-              logger: debugLogger8
-            });
+            const replay = await profiler.time(
+              "history_replay",
+              () => collectHistoryReplayUpdates({
+                sessionId,
+                config,
+                records: replayPage.records,
+                gaps: replayPage.gaps,
+                cumulativeUsage: createReplayCumulativeUsage(),
+                replayState: replayPage.replay,
+                goalBootstrap: replayGoalBootstrap(projection),
+                ...restoreOptions.replay.kind === "recent" ? {
+                  limits: {
+                    maxBytes: LOAD_REPLAY_MAX_BYTES,
+                    maxUpdates: LOAD_REPLAY_MAX_UPDATES
+                  }
+                } : {},
+                logger: debugLogger8
+              })
+            );
+            addDaemonRequestAttribute(
+              "qwen-code.daemon.session_restore.partial_replay",
+              replay.replayError !== void 0
+            );
             if (!bulkReplay) {
               try {
                 for (const update of replay.updates) {
@@ -13805,18 +14669,25 @@ var QwenAgent = class {
               }
               return response;
             }
+            const envelope = {
+              v: LOAD_REPLAY_VERSION,
+              updates: replay.updates,
+              ...replayPage.anchorRecordId ? { anchorRecordId: replayPage.anchorRecordId } : {},
+              ...replay.replayError !== void 0 ? {
+                partial: true,
+                replayError: replay.replayError
+              } : {},
+              ...replayPage.hasMore ? { hasMore: true } : {}
+            };
+            validateLoadReplayEnvelope(
+              sessionId,
+              envelope,
+              restoreOptions.replay.kind === "recent"
+            );
             return {
               ...response,
               _meta: {
-                [LOAD_REPLAY_META_KEY]: {
-                  v: LOAD_REPLAY_VERSION,
-                  updates: replay.updates,
-                  ...replay.replayError !== void 0 ? {
-                    partial: true,
-                    replayError: replay.replayError
-                  } : {},
-                  ...replayPage.hasMore ? { hasMore: true } : {}
-                }
+                [LOAD_REPLAY_META_KEY]: envelope
               }
             };
           }
@@ -13858,13 +14729,32 @@ var QwenAgent = class {
           settings,
           sessionSource,
           sessionId,
-          true
+          true,
+          {},
+          void 0,
+          restoreOptions
         )
       );
-      const sessionData = config.getResumedSessionData();
+      const projection = config.consumeSessionRestoreProjection?.();
+      const suppressRecoveredGoalPresentation = projection?.runtime.goalRecoverySourceUuid !== void 0 && projection.runtime.goalRecoverySourceUuid !== projection.replay?.goalRecoverySourceUuid;
       const bulkReplay = isBulkLoadReplayRequest(params);
-      const replayPageSize = bulkReplay ? getLoadReplayPageSize(params) : void 0;
       let replayEnvelope;
+      const replayUsage = createReplayCumulativeUsage();
+      let recoveredGoalPublicationKey;
+      let suppressedRecoveredGoalId;
+      let streamGoalUpdates = [];
+      let response;
+      const buildResponse = /* @__PURE__ */ __name(() => profiler.timeSync("response_build", () => ({
+        modes: this.buildModesData(config),
+        models: this.buildAvailableModels(config),
+        configOptions: this.buildConfigOptions(config),
+        ...projection?.runtime.artifactSnapshot ? { artifactSnapshot: projection.runtime.artifactSnapshot } : {},
+        ...replayEnvelope ? {
+          _meta: {
+            [LOAD_REPLAY_META_KEY]: replayEnvelope
+          }
+        } : {}
+      })), "buildResponse");
       try {
         await profiler.time("auth", () => this.ensureAuthenticated(config));
         profiler.timeSync(
@@ -13873,91 +14763,165 @@ var QwenAgent = class {
         );
         await profiler.time(
           "session_register",
-          () => this.createAndStoreSession(config, settings, sessionData, {
+          () => this.createAndStoreSession(config, settings, void 0, {
             enableLiveScreenContext: isCompatibleLiveSessionSource(
               sessionSource ?? {}
             ),
-            ...bulkReplay ? { replayHistory: false } : {},
-            beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
-              if (bulkReplay) {
-                const records = sessionData?.conversation.messages;
-                let replayUpdates = [];
-                if (records) {
-                  createdSession.primeTurnFromHistory(records);
-                  const visibleRecords = selectVisibleHistoryRecords(
-                    records,
-                    shouldHideInheritedHistory(params)
-                  );
-                  const replayPage = selectRecentHistoryRecords(
-                    visibleRecords,
-                    replayPageSize
-                  );
-                  const replayUsage = createReplayCumulativeUsage();
-                  const replay = await collectHistoryReplayUpdates({
+            replayHistory: false,
+            prepareBeforeSessionCreate: /* @__PURE__ */ __name(async () => {
+              if (bulkReplay && projection?.replay) {
+                const replay = await profiler.time(
+                  "history_replay",
+                  () => collectHistoryReplayUpdates({
                     sessionId,
                     config,
-                    records: replayPage.records,
-                    gaps: sessionData?.historyGaps,
+                    records: projection.replay.records,
+                    gaps: projection.replay.gaps,
                     cumulativeUsage: replayUsage,
-                    supersedeUnrestorableGoal: true,
+                    replayState: projection.replay.replay,
+                    goalBootstrap: replayGoalBootstrap(projection),
+                    ...restoreOptions.replay.kind === "recent" ? {
+                      limits: {
+                        maxBytes: LOAD_REPLAY_MAX_BYTES,
+                        maxUpdates: LOAD_REPLAY_MAX_UPDATES
+                      }
+                    } : {},
                     logger: debugLogger8
-                  });
-                  replayUpdates = replay.updates;
-                  copyCumulativeUsage(
-                    createdSession.cumulativeUsage,
-                    replayUsage
-                  );
-                  if (replay.replayError !== void 0) {
-                    replayEnvelope = {
-                      v: LOAD_REPLAY_VERSION,
-                      updates: replayUpdates,
-                      partial: true,
-                      replayError: replay.replayError,
-                      ...replayPage.hasMore ? { hasMore: true } : {}
-                    };
-                  }
-                  replayEnvelope ??= {
-                    v: LOAD_REPLAY_VERSION,
-                    updates: replayUpdates,
-                    ...replayPage.hasMore ? { hasMore: true } : {}
-                  };
+                  })
+                );
+                addDaemonRequestAttribute(
+                  "qwen-code.daemon.session_restore.partial_replay",
+                  replay.replayError !== void 0
+                );
+                replayEnvelope = {
+                  v: LOAD_REPLAY_VERSION,
+                  updates: replay.updates,
+                  ...projection.replay.anchorRecordId ? { anchorRecordId: projection.replay.anchorRecordId } : {},
+                  ...replay.replayError !== void 0 ? {
+                    partial: true,
+                    replayError: replay.replayError
+                  } : {},
+                  ...projection.replay.hasMore ? { hasMore: true } : {}
+                };
+                validateLoadReplayEnvelope(
+                  sessionId,
+                  replayEnvelope,
+                  restoreOptions.replay.kind === "recent"
+                );
+              }
+              const goalBootstrap = replayGoalBootstrap(projection);
+              const rendered = await renderPreparedGoalUpdate(
+                () => config.getGoalRuntimePrepared(),
+                {
+                  ...projection?.replay?.records ? { replayedRecords: projection.replay.records } : {},
+                  ...suppressRecoveredGoalPresentation ? { hideRuntimeGoal: true } : {},
+                  ...goalBootstrap ? { bootstrap: goalBootstrap } : {}
                 }
+              ).catch((error) => {
+                if (suppressRecoveredGoalPresentation) throw error;
+                debugLogger8.debug(
+                  `Failed to render recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+                );
+                return {
+                  publicationKey: void 0,
+                  suppressedGoalId: void 0,
+                  updates: []
+                };
+              });
+              recoveredGoalPublicationKey = rendered.publicationKey;
+              suppressedRecoveredGoalId = rendered.suppressedGoalId;
+              if (!bulkReplay) {
+                streamGoalUpdates = rendered.updates;
+                return;
+              }
+              const goalUpdates = rendered.updates;
+              if (goalUpdates.length > 0) {
                 replayEnvelope ??= {
                   v: LOAD_REPLAY_VERSION,
-                  updates: replayUpdates
+                  updates: []
                 };
+                replayEnvelope.updates.push(...goalUpdates);
+                validateLoadReplayEnvelope(
+                  sessionId,
+                  replayEnvelope,
+                  restoreOptions.replay.kind === "recent"
+                );
               }
-              await this.#restoreWorktreeOnResume(config, createdSession);
-              await this.#restoreBackgroundAgentsOnResume(
-                config,
-                createdSession
-              );
-              this.#restoreGoalOnResume(config, createdSession);
+            }, "prepareBeforeSessionCreate"),
+            beforeSessionCreate: /* @__PURE__ */ __name(() => {
+              response = buildResponse();
+            }, "beforeSessionCreate"),
+            primeSession: /* @__PURE__ */ __name((createdSession) => {
+              profiler.timeSync("runtime_initialize", () => {
+                if (!projection) return;
+                createdSession.primeTurnState(
+                  projection.runtime.initialTurn,
+                  projection.runtime.backgroundNotificationTaskIds
+                );
+                copyCumulativeUsage(
+                  createdSession.cumulativeUsage,
+                  replayUsage
+                );
+                createdSession.primeRecoveredGoalPublication(
+                  recoveredGoalPublicationKey,
+                  suppressedRecoveredGoalId
+                );
+              });
+            }, "primeSession"),
+            beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+              if (!bulkReplay && projection?.replay) {
+                await profiler.time("history_replay", async () => {
+                  const goalBootstrap = replayGoalBootstrap(projection);
+                  const initialGoalState = replayInitialGoalState(projection);
+                  const hasGoalReplayState = goalBootstrap !== void 0 || initialGoalState.initialGoalState !== void 0 || initialGoalState.initialGoalCause !== void 0;
+                  if (hasGoalReplayState) {
+                    await createdSession.replayHistory(
+                      projection.replay.records,
+                      projection.replay.gaps,
+                      {
+                        ...goalBootstrap ? { goalBootstrap } : {},
+                        ...initialGoalState
+                      }
+                    );
+                  } else {
+                    await createdSession.replayHistory(
+                      projection.replay.records,
+                      projection.replay.gaps
+                    );
+                  }
+                });
+                try {
+                  for (const update of streamGoalUpdates) {
+                    await createdSession.sendUpdate(update);
+                  }
+                } catch (error) {
+                  debugLogger8.debug(
+                    `Failed to publish recovered Goal state: ${error instanceof Error ? error.message : String(error)}`
+                  );
+                }
+              }
+              await profiler.time("post_replay_services", async () => {
+                await this.#restoreWorktreeOnResume(config, createdSession);
+                await this.#restoreBackgroundAgentsOnResume(
+                  config,
+                  createdSession
+                );
+              });
             }, "beforeStartPostReplayServices")
           })
         );
       } catch (error) {
-        return this.cleanupAfterRequestFailure(error, async () => {
-          if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
-            await this.cleanupUnstoredConfig(config);
-          }
-        });
+        return this.cleanupAfterRequestFailure(
+          error,
+          async () => {
+            if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
+              await this.cleanupUnstoredConfig(config);
+            }
+          },
+          sessionId
+        );
       }
-      return profiler.timeSync("response_build", () => {
-        const response = {
-          modes: this.buildModesData(config),
-          models: this.buildAvailableModels(config),
-          configOptions: this.buildConfigOptions(config),
-          ...sessionData?.artifactSnapshot ? { artifactSnapshot: sessionData.artifactSnapshot } : {}
-        };
-        if (!replayEnvelope) return response;
-        return {
-          ...response,
-          _meta: {
-            [LOAD_REPLAY_META_KEY]: replayEnvelope
-          }
-        };
-      });
+      return response;
     } finally {
       releaseStartingSessionId();
     }
@@ -13995,13 +14959,14 @@ var QwenAgent = class {
         return this.withLiveSessionRestore(
           sessionId,
           liveSession,
-          async (config, sessionData) => profiler.timeSync(
+          RESUME_RESTORE_OPTIONS,
+          async (config, projection) => profiler.timeSync(
             "response_build",
             () => ({
               modes: this.buildModesData(config),
               models: this.buildAvailableModels(config),
               configOptions: this.buildConfigOptions(config),
-              ...sessionData.artifactSnapshot ? { artifactSnapshot: sessionData.artifactSnapshot } : {}
+              ...projection?.artifactSnapshot ? { artifactSnapshot: projection.artifactSnapshot } : {}
             })
           )
         );
@@ -14038,9 +15003,14 @@ var QwenAgent = class {
           settings,
           sessionSource,
           sessionId,
-          true
+          true,
+          {},
+          void 0,
+          RESUME_RESTORE_OPTIONS
         )
       );
+      const projection = config.consumeSessionRestoreProjection?.();
+      let response;
       try {
         await profiler.time("auth", () => this.ensureAuthenticated(config));
         profiler.timeSync(
@@ -14049,43 +15019,51 @@ var QwenAgent = class {
         );
         await profiler.time(
           "session_register",
-          () => this.createAndStoreSession(
-            config,
-            settings,
-            config.getResumedSessionData(),
-            {
-              enableLiveScreenContext: isCompatibleLiveSessionSource(
-                sessionSource ?? {}
-              ),
-              replayHistory: false,
-              beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+          () => this.createAndStoreSession(config, settings, void 0, {
+            enableLiveScreenContext: isCompatibleLiveSessionSource(
+              sessionSource ?? {}
+            ),
+            replayHistory: false,
+            beforeSessionCreate: /* @__PURE__ */ __name(() => {
+              response = profiler.timeSync("response_build", () => ({
+                modes: this.buildModesData(config),
+                models: this.buildAvailableModels(config),
+                configOptions: this.buildConfigOptions(config),
+                ...projection?.runtime.artifactSnapshot ? { artifactSnapshot: projection.runtime.artifactSnapshot } : {}
+              }));
+            }, "beforeSessionCreate"),
+            primeSession: /* @__PURE__ */ __name((createdSession) => {
+              profiler.timeSync("runtime_initialize", () => {
+                if (!projection) return;
+                createdSession.primeTurnState(
+                  projection.runtime.initialTurn,
+                  projection.runtime.backgroundNotificationTaskIds
+                );
+              });
+            }, "primeSession"),
+            beforeStartPostReplayServices: /* @__PURE__ */ __name(async (createdSession) => {
+              await profiler.time("post_replay_services", async () => {
                 await this.#restoreWorktreeOnResume(config, createdSession);
                 await this.#restoreBackgroundAgentsOnResume(
                   config,
                   createdSession
                 );
-                this.#restoreGoalOnResume(config, createdSession);
-              }, "beforeStartPostReplayServices")
-            }
-          )
+              });
+            }, "beforeStartPostReplayServices")
+          })
         );
       } catch (error) {
-        return this.cleanupAfterRequestFailure(error, async () => {
-          if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
-            await this.cleanupUnstoredConfig(config);
-          }
-        });
+        return this.cleanupAfterRequestFailure(
+          error,
+          async () => {
+            if (this.sessions.get(config.getSessionId())?.getConfig() !== config) {
+              await this.cleanupUnstoredConfig(config);
+            }
+          },
+          sessionId
+        );
       }
-      const sessionData = config.getResumedSessionData();
-      return profiler.timeSync(
-        "response_build",
-        () => ({
-          modes: this.buildModesData(config),
-          models: this.buildAvailableModels(config),
-          configOptions: this.buildConfigOptions(config),
-          ...sessionData?.artifactSnapshot ? { artifactSnapshot: sessionData.artifactSnapshot } : {}
-        })
-      );
+      return response;
     } finally {
       releaseStartingSessionId();
     }
@@ -14111,48 +15089,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 +15169,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 +15227,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 +19354,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 +19392,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
         };
       }
@@ -19412,7 +20395,7 @@ ${outputText}
       throw error;
     }
   }
-  async newSessionConfig(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording) {
+  async newSessionConfig(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions) {
     try {
       this.assertManagedSessionAdmission();
       return await this.runWithPinnedRuntimeBaseDir(settings, cwd, async () => {
@@ -19428,7 +20411,8 @@ ${outputText}
           sessionId,
           resume,
           initializeOptions,
-          chatRecording
+          chatRecording,
+          restoreOptions
         );
       });
     } catch (error) {
@@ -19444,10 +20428,10 @@ ${outputText}
           errorKind: writerError.errorKind
         });
       }
-      throw error;
+      throw sessionId && restoreOptions ? mapSessionRestoreRequestError(error, sessionId) : error;
     }
   }
-  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording) {
+  async newSessionConfigInRuntimeContext(cwd, mcpServers, settings, sessionSource, sessionId, resume, initializeOptions = {}, chatRecording, restoreOptions) {
     const sessionMcpServers = {};
     for (const server of mcpServers) {
       const stdioServer = toStdioServer(server);
@@ -19545,7 +20529,19 @@ ${outputText}
       // not process.exit(1) the shared ACP child and every session on its
       // channel. newSessionConfig maps the throw to a RequestError.
       true,
-      this.managedToolInvocationGuard ? { toolInvocationGuard: this.managedToolInvocationGuard } : void 0
+      this.managedToolInvocationGuard || restoreOptions ? {
+        ...this.managedToolInvocationGuard ? { toolInvocationGuard: this.managedToolInvocationGuard } : {},
+        ...restoreOptions && sessionId ? {
+          sessionRestore: {
+            projectionSource: /* @__PURE__ */ __name((restoreSessionId) => new SessionService(cwd, {
+              runtimeBaseDir: Storage.getRuntimeBaseDir()
+            }).readRestoreProjection(
+              restoreSessionId,
+              restoreOptions
+            ), "projectionSource")
+          }
+        } : {}
+      } : void 0
     );
     if (sessionSource) {
       config.setSessionSource(sessionSource.sourceType, sessionSource.sourceId);
@@ -19682,6 +20678,16 @@ ${outputText}
         { errorKind: "session_id_conflict", sessionId }
       );
     }
+    await options.prepareBeforeSessionCreate?.();
+    this.assertManagedSessionAdmission();
+    if (this.sessions.has(sessionId)) {
+      throw new RequestError(
+        ACP_ERROR_CODES.INVALID_PARAMS,
+        `Session ${sessionId} is already active.`,
+        { errorKind: "session_id_conflict", sessionId }
+      );
+    }
+    options.beforeSessionCreate?.();
     const session = new Session(
       sessionId,
       config,
@@ -19689,10 +20695,14 @@ ${outputText}
       settings,
       () => this.activeWorkReporter?.notifyChanged()
     );
-    this.sessions.set(sessionId, session);
-    this.activeWorkReporter?.notifyChanged();
-    this.initializingConfigs.delete(config);
+    let published = false;
     try {
+      options.primeSession?.(session);
+      config.hydrateSessionRestoreFileHistory?.();
+      this.sessions.set(sessionId, session);
+      published = true;
+      this.activeWorkReporter?.notifyChanged();
+      this.initializingConfigs.delete(config);
       if (options.enableLiveScreenContext) {
         await session.enableLiveScreenContext();
       }
@@ -19707,15 +20717,35 @@ ${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();
+      config.finalizeSessionRestore?.();
       session.startCronScheduler();
       setTimeout(() => {
         void session.sendAvailableCommandsUpdate();
       }, 0);
       return session;
     } catch (error) {
+      if (!published) {
+        try {
+          session.dispose();
+        } catch (disposeError) {
+          debugLogger8.warn(
+            `Failed to dispose unpublished session ${sessionId}: ${disposeError instanceof Error ? disposeError.message : String(disposeError)}`
+          );
+        }
+        throw error;
+      }
       try {
         await this.discardStoredSessionIfCurrent(sessionId, session, {
           shutdownConfig: false
@@ -19807,13 +20837,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 +20887,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(