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

package/chunks/{startInteractiveUI-J45WOEOU.js → startInteractiveUI-FKILLW7Q.js}

@@ -1,5 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  startPostRenderPrefetches
+} from "./chunk-FG63DZQA.js";
+import {
+  useAutoAcceptIndicator
+} from "./chunk-RL6J3BPE.js";
 import {
   classifyApiError,
   fireSessionDeleteHook
@@ -10,7 +16,7 @@ import {
 import {
   TUI_CHAT_RECORDING_FAILURE_MESSAGE,
   reportChatRecordingFailureToAdapter
-} from "./chunk-LRJWFR6L.js";
+} from "./chunk-ZGSUFIL5.js";
 import {
   MAX_SUGGESTIONS_TO_SHOW,
   SESSION_MENTION_PREFIX,
@@ -22,10 +28,10 @@ import {
   matchMcpServerPrefix,
   resolveAtCommandQuery,
   sanitizeDisplayText
-} from "./chunk-RGJ4JWSU.js";
+} from "./chunk-XMJO6C44.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-OCRM53TT.js";
+} from "./chunk-L7FTDKCD.js";
 import {
   BuiltinCommandLoader,
   BundledSkillLoader,
@@ -66,18 +72,21 @@ import {
   resetBackgroundStateForSessionSwitch,
   serializeUserPromptExpansionPrompt,
   supportsMatchers
-} from "./chunk-TNVKFQXQ.js";
-import "./chunk-7K2WTPQO.js";
-import {
-  startPostRenderPrefetches
-} from "./chunk-FJHA23GM.js";
+} from "./chunk-4AGGSHCH.js";
 import {
   EXTENSION_RELOAD_FAILED_REASON,
   ExtensionRefreshState,
   appEvents,
   cleanupReviewWorktreeLeases,
   loadHierarchicalGeminiMemory
-} from "./chunk-VS3GXRNZ.js";
+} from "./chunk-QPSYIV2O.js";
+import {
+  disableKittyProtocol,
+  isKittyProtocolEnabled,
+  isKittyProtocolSupported,
+  pushKittyProtocolFlags
+} from "./chunk-NYX53SV4.js";
+import "./chunk-SKSF3LGQ.js";
 import {
   AboutBox,
   BaseSelectionList,
@@ -143,6 +152,7 @@ import {
   useIdeTrustListener,
   useLaunchEditor,
   useMouseEvents,
+  useMouseTrackingEnabled,
   usePreferredEditor,
   useProviderUpdates,
   useSelectionList,
@@ -154,15 +164,34 @@ import {
   useUIActions,
   useUIState,
   useVirtualViewport
-} from "./chunk-WISQLM4Q.js";
+} from "./chunk-H6FIBBXK.js";
+import {
+  KeypressProvider,
+  useFocus,
+  useKeypress,
+  useKeypressContext
+} from "./chunk-Q3G5L5KF.js";
 import {
   getCommandDisplayName,
   getCommandSourceBadge
-} from "./chunk-OBAIHYFT.js";
+} from "./chunk-TXABHVZD.js";
 import {
   computeSessionStats,
   levelLabel
-} from "./chunk-7IYLHTTM.js";
+} from "./chunk-LZV2BZPL.js";
+import {
+  BEL,
+  OSC_PREFIX,
+  cleanupOldClipboardImages,
+  clipboardHasImage,
+  detectTerminal,
+  generateKittyId,
+  oscGhosttyNotify,
+  oscITerm2Notify,
+  oscKittyNotify,
+  saveClipboardImage,
+  writeOsc52
+} from "./chunk-3LGZEYOF.js";
 import "./chunk-4WGODMVR.js";
 import {
   MaxSizedBox,
@@ -181,42 +210,13 @@ import {
   build_default,
   expandCollapsedHistory,
   isCollapsibleTool,
-  useStreamingContext
-} from "./chunk-KG22G46Y.js";
+  shouldDisplayGoalStateCause,
+  useStreamingContext,
+  waitForGoalRuntime
+} from "./chunk-NW57GHNL.js";
 import {
   theme
 } from "./chunk-U25CMJYY.js";
-import {
-  stopAndGetCapturedInput
-} from "./chunk-KVUBYJDM.js";
-import {
-  disableKittyProtocol,
-  isKittyProtocolEnabled,
-  isKittyProtocolSupported,
-  pushKittyProtocolFlags
-} from "./chunk-NYX53SV4.js";
-import {
-  useAutoAcceptIndicator
-} from "./chunk-MSIVKDRC.js";
-import {
-  KeypressProvider,
-  useFocus,
-  useKeypress,
-  useKeypressContext
-} from "./chunk-H4DSRWAS.js";
-import {
-  BEL,
-  OSC_PREFIX,
-  cleanupOldClipboardImages,
-  clipboardHasImage,
-  detectTerminal,
-  generateKittyId,
-  oscGhosttyNotify,
-  oscITerm2Notify,
-  oscKittyNotify,
-  saveClipboardImage,
-  writeOsc52
-} from "./chunk-3LGZEYOF.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -234,38 +234,41 @@ import {
   use_stdin_default,
   use_stdout_default
 } from "./chunk-2IIJTXYF.js";
+import {
+  require_react
+} from "./chunk-5QWWOFGG.js";
+import {
+  stopAndGetCapturedInput
+} from "./chunk-KVUBYJDM.js";
+import "./chunk-PWCQRLM5.js";
 import {
   relaunchApp
-} from "./chunk-42IKVPST.js";
+} from "./chunk-FF75UUB2.js";
 import {
   setUpdateHandler
-} from "./chunk-C4L2MEIT.js";
-import "./chunk-WP4HGHFG.js";
+} from "./chunk-3MWNROHB.js";
+import "./chunk-YWMDTMAU.js";
+import "./chunk-MUEJ4R3E.js";
 import {
   AUTO_THEME_NAME,
   DEFAULT_THEME,
   themeManager
 } from "./chunk-KKN2IE7Q.js";
 import "./chunk-KW7NOTN6.js";
-import {
-  require_react
-} from "./chunk-5QWWOFGG.js";
-import "./chunk-433VD3HX.js";
+import "./chunk-BSKUTHLO.js";
+import "./chunk-6H67XLET.js";
+import "./chunk-MTR4JWQJ.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-PHODQP2V.js";
-import "./chunk-VWF42XC6.js";
-import "./chunk-ZRFJ75D7.js";
+} from "./chunk-EGYJRIDF.js";
+import "./chunk-IWGTGH4G.js";
 import "./chunk-YAF2MQZ6.js";
 import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
 } from "./chunk-GTM6IHBB.js";
-import {
-  recordGoalStatusItem,
-  restoreGoalFromHistory
-} from "./chunk-UOFFZNXV.js";
+import "./chunk-VUNRNRN6.js";
 import "./chunk-DYA25Y7U.js";
 import {
   cpLen,
@@ -279,36 +282,45 @@ import {
   stripUnsafeCharacters,
   toCodePoints
 } from "./chunk-4NFY2S7N.js";
-import "./chunk-UHQ3L6GC.js";
+import "./chunk-N42C2FU3.js";
 import {
   stringWidth
 } from "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import {
   isHistoryItemVisibleAfterRestore
-} from "./chunk-QTERJVPZ.js";
+} from "./chunk-EKTCKZV5.js";
 import "./chunk-3Z43GZUQ.js";
 import "./chunk-RXFQM6FQ.js";
-import "./chunk-LL4U3BSH.js";
-import "./chunk-6H67XLET.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isKeytermEcho,
   isStreamingVoiceModel,
   resolveVoiceStreamConfig,
   transcribeVoiceAudio
-} from "./chunk-2A6MHYIA.js";
+} from "./chunk-WY2ENRDN.js";
 import {
   formatUnsupportedVoiceModelMessage,
   isSelectableVoiceModel
-} from "./chunk-XSA5EKTJ.js";
+} from "./chunk-BKGA75MU.js";
 import "./chunk-JELIWHXD.js";
+import {
+  computeWorkspaceSkillListUpdates,
+  resolveSkillSettings,
+  skillSettingStrings
+} from "./chunk-Z4X5MTRT.js";
+import "./chunk-2LZCLQIS.js";
+import {
+  requestConsentInteractive,
+  requestConsentOrFail
+} from "./chunk-D2GPKXCQ.js";
+import "./chunk-57OAHC2Y.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-K5Q62CGR.js";
+} from "./chunk-IF6K42YJ.js";
 import {
   getExtendedSystemInfo
-} from "./chunk-GHJM2C2T.js";
+} from "./chunk-QWDVZH24.js";
 import {
   formatDuration,
   formatRelativeTime,
@@ -318,36 +330,26 @@ import "./chunk-GLWP3FDB.js";
 import "./chunk-XCGIMOLN.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-AYB4HSBI.js";
-import {
-  computeWorkspaceSkillListUpdates,
-  resolveSkillSettings,
-  skillSettingStrings
-} from "./chunk-Z4X5MTRT.js";
-import "./chunk-3WXMXT7C.js";
-import {
-  requestConsentInteractive,
-  requestConsentOrFail
-} from "./chunk-BKUN5QHP.js";
-import "./chunk-57OAHC2Y.js";
-import "./chunk-2CTKGIFR.js";
-import "./chunk-K4CGQN4Q.js";
-import "./chunk-ZTN6OA5J.js";
+} from "./chunk-5VYFXHY2.js";
+import "./chunk-LGT3YMLN.js";
+import "./chunk-X6WUYMOV.js";
+import "./chunk-VWOVHOTT.js";
 import "./chunk-V6WHFGST.js";
+import "./chunk-DP3IHZGG.js";
 import "./chunk-6PLDPT2C.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-QONSRAEV.js";
-import "./chunk-UHTJC7O3.js";
+import "./chunk-24ER7UV4.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-XC2VAFVZ.js";
-import "./chunk-I6FAHB4N.js";
-import "./chunk-GB3AB7TR.js";
+import "./chunk-WUC6ZFXO.js";
+import "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import {
   loadMcpApprovals
-} from "./chunk-NZB4NDJL.js";
+} from "./chunk-2MI7ZTRT.js";
 import {
   CORRUPTED_SUFFIX,
   SettingScope,
@@ -370,7 +372,7 @@ import {
   settingExistsInScope,
   validateSettingValue,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-LAPK3GLC.js";
+} from "./chunk-22YFMJBW.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -379,25 +381,24 @@ import {
   localizeToolDisplayName,
   t,
   ta
-} from "./chunk-CHCLO3M7.js";
-import "./chunk-AQEWCKX4.js";
+} from "./chunk-KXWERR6P.js";
+import "./chunk-6NE5NTHJ.js";
 import "./chunk-6PEXNQTX.js";
-import "./chunk-DP3IHZGG.js";
-import "./chunk-25QQVOCG.js";
+import "./chunk-FXVHVCNA.js";
+import {
+  getCliVersion
+} from "./chunk-BKXTHMOZ.js";
+import "./chunk-VJNBRRZG.js";
 import {
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-434YCHSV.js";
+} from "./chunk-M5LIY7Y6.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import "./chunk-XFSFZCM5.js";
 import "./chunk-URK542T4.js";
-import {
-  getCliVersion
-} from "./chunk-MBKPUM5Y.js";
-import "./chunk-VJNBRRZG.js";
 import {
   ALIBABA_PROVIDERS,
   AsyncFzf,
@@ -423,7 +424,6 @@ import {
   THIRD_PARTY_PROVIDERS,
   abortSpeculation,
   acceptSpeculation,
-  activeGoalEquals,
   aggregateUsage,
   allowEditorTypeInSandbox,
   applyProviderInstallPlan,
@@ -433,7 +433,6 @@ import {
   checkForExtensionUpdate,
   checkHasEditorType,
   clampInlineMediaPart,
-  clearActiveGoal,
   clearWelcomeBackState,
   clearWorktreeSession,
   compactToolResultDisplayForHistory,
@@ -458,7 +457,6 @@ import {
   generatePromptSuggestion,
   generateSessionRecap,
   generateToolUseSummary,
-  getActiveGoal,
   getDefaultBaseUrlForProtocol,
   getDefaultModelIds,
   getExtensionDisplayName,
@@ -496,7 +494,6 @@ import {
   restoreWorktreeContext,
   saveWelcomeBackRestartChoice,
   saveWorkflowScript,
-  setActiveGoal,
   shouldShowStep,
   startSpeculation,
   stripTerminalControlSequences,
@@ -504,27 +501,28 @@ import {
   validateWorkflowName,
   watchRepoBranch,
   writeRuntimeStatus
-} from "./chunk-NGWYUZZO.js";
+} from "./chunk-UQDFEU47.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-CWEIMFFW.js";
+import "./chunk-VA5NLVPT.js";
 import "./chunk-I7JDGNG6.js";
 import "./chunk-A6SX5TAH.js";
 import "./chunk-33FNCQSY.js";
 import "./chunk-6PVPNMXU.js";
 import {
   resolveModelId
-} from "./chunk-PXA5AWHY.js";
+} from "./chunk-XUMAD5IT.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import "./chunk-MOHAWIAW.js";
-import "./chunk-MYT7N6QH.js";
+import "./chunk-X6QNZOTC.js";
 import {
   promptIdContext
 } from "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
+import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
 import "./chunk-MISUEWB4.js";
 import "./chunk-KRXPRVGL.js";
@@ -533,20 +531,24 @@ import {
 } from "./chunk-A5YZ3FA2.js";
 import "./chunk-YAVY33G4.js";
 import "./chunk-2UISUFHQ.js";
-import "./chunk-6FMJLI5M.js";
+import {
+  elapsedActiveTime,
+  goalRequiresExactPermit
+} from "./chunk-HFVW54NL.js";
 import {
   APPROVAL_MODES,
-  getStartupContextLength,
-  isSystemReminderContent,
   runOutsideAgentContext
-} from "./chunk-PGEGUNH5.js";
+} from "./chunk-TZTBZ25J.js";
 import "./chunk-S6LOFUVP.js";
+import {
+  getStartupContextLength,
+  isSystemReminderContent
+} from "./chunk-SRY26X4H.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import {
   isPathWithinRoot
 } from "./chunk-432XCUHF.js";
-import "./chunk-ZPJWUGCS.js";
 import {
   osc8Hyperlink,
   qwenOAuth2Events,
@@ -566,7 +568,7 @@ import {
 } from "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-XCLLRKY5.js";
+import "./chunk-EIMKVOSF.js";
 import "./chunk-RPYYTL7E.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
@@ -613,7 +615,7 @@ import {
   runVisionBridge,
   shouldRunVisionBridge,
   splitImageParts
-} from "./chunk-M2F5PLOW.js";
+} from "./chunk-4K3RV3OA.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   AUTO_MEMORY_INDEX_FILENAME,
@@ -622,14 +624,14 @@ import {
   getUserAutoMemoryRoot,
   isAnyAutoMemPath
 } from "./chunk-E4WHKETF.js";
-import "./chunk-BV4QX43X.js";
+import "./chunk-UEJESCS7.js";
 import {
   ToolNames,
   isShellProgressData
-} from "./chunk-I5GNT6ZS.js";
+} from "./chunk-CFDR3GNL.js";
 import {
   MAINLINE_CODER_MODEL
-} from "./chunk-TFFMATHX.js";
+} from "./chunk-H35Q5CEG.js";
 import "./chunk-46UV252V.js";
 import {
   DEFAULT_TOKEN_LIMIT
@@ -655,11 +657,11 @@ import {
   tildeifyPath
 } from "./chunk-3RXUYQJI.js";
 import "./chunk-VOQXFAY5.js";
-import "./chunk-W7XZ3KP5.js";
+import "./chunk-R7XNRHYD.js";
 import {
   registerCleanup,
   runExitCleanup
-} from "./chunk-SK2UKB45.js";
+} from "./chunk-QDWLUXKP.js";
 import {
   finalizeStartupProfile,
   profileCheckpoint
@@ -2356,6 +2358,7 @@ function isSyntheticHistoryItem(item) {
     case "arena_agent_complete":
     case "arena_session_complete":
     case "goal_status":
+    case "goal_state":
       return false;
     default: {
       const _exhaustive = item;
@@ -11054,6 +11057,7 @@ function ModelDialog({
   isFastModelMode,
   isVoiceModelMode,
   isVisionModelMode,
+  isCompactionModelMode,
   isImageModelMode,
   persistScope,
   availableTerminalHeight
@@ -11072,7 +11076,7 @@ function ModelDialog({
         buildModelSelectionKey(m.authType, m.id, m.baseUrl)
       );
       const isSelectableImageModel = isImageModelMode ? m.imageOnly === true && config?.resolveImageGenerationModel(imageModelSelector) !== void 0 : m.imageOnly !== true;
-      return !m.isRuntimeModel && (m.authType !== "qwen-oauth" /* QWEN_OAUTH */ || authType === "qwen-oauth" /* QWEN_OAUTH */) && isSelectableImageModel && (isFastModelMode || !m.fastOnly) && (isVoiceModelMode || !m.voiceOnly);
+      return !m.isRuntimeModel && (m.authType !== "qwen-oauth" /* QWEN_OAUTH */ || authType === "qwen-oauth" /* QWEN_OAUTH */) && isSelectableImageModel && (isFastModelMode || !m.fastOnly) && (isVoiceModelMode || !m.voiceOnly) && (isVisionModelMode || !m.visionOnly);
     });
     const modelsByAuthTypeMap = /* @__PURE__ */ new Map();
     for (const model of registryModels) {
@@ -11108,7 +11112,14 @@ function ModelDialog({
       }
     }
     return result;
-  }, [authType, config, isFastModelMode, isImageModelMode, isVoiceModelMode]);
+  }, [
+    authType,
+    config,
+    isFastModelMode,
+    isImageModelMode,
+    isVoiceModelMode,
+    isVisionModelMode
+  ]);
   const MODEL_OPTIONS = (0, import_react34.useMemo)(
     () => availableModelEntries.map(
       ({ authType: t2, model, isRuntime, snapshotId }) => {
@@ -11202,7 +11213,7 @@ function ModelDialog({
     }
   }, [parsedImageModelValue?.selector, isImageModelMode]);
   const preferredModelId = isFastModelMode && parsedFastModelSetting ? parsedFastModelSetting.modelId : isVisionModelMode && parsedVisionModelSetting ? parsedVisionModelSetting.modelId : isImageModelMode && parsedImageModelSetting ? parsedImageModelSetting.modelId : config?.getModel() || MAINLINE_CODER_MODEL;
-  const activeRuntimeSnapshot = isFastModelMode || isVoiceModelMode || isVisionModelMode || isImageModelMode ? void 0 : config?.getActiveRuntimeModelSnapshot?.();
+  const activeRuntimeSnapshot = isFastModelMode || isVoiceModelMode || isVisionModelMode || isCompactionModelMode || isImageModelMode ? void 0 : config?.getActiveRuntimeModelSnapshot?.();
   const currentBaseUrl = config?.getModelsConfig().getGenerationConfig()?.baseUrl;
   const preferredFastModelEntry = isFastModelMode && parsedFastModelSetting ? parsedFastModelSetting.authType ? availableModelEntries.find(
     ({ authType: t2, model }) => t2 === parsedFastModelSetting.authType && model.id === parsedFastModelSetting.modelId
@@ -11223,6 +11234,21 @@ function ModelDialog({
   ) : availableModelEntries.find(
     ({ model }) => model.id === parsedImageModelSetting.modelId && (!parsedImageModelValue?.baseUrl || model.baseUrl === parsedImageModelValue.baseUrl)
   ) : void 0;
+  const parsedCompactionSetting = (0, import_react34.useMemo)(() => {
+    if (!isCompactionModelMode) return void 0;
+    const raw = settings?.merged?.compactionModel?.trim();
+    if (!raw) return void 0;
+    try {
+      return resolveModelId(raw);
+    } catch {
+      return void 0;
+    }
+  }, [settings?.merged?.compactionModel, isCompactionModelMode]);
+  const preferredCompactionModelEntry = isCompactionModelMode && parsedCompactionSetting ? parsedCompactionSetting.authType ? availableModelEntries.find(
+    ({ authType: t2, model }) => t2 === parsedCompactionSetting.authType && model.id === parsedCompactionSetting.modelId
+  ) : availableModelEntries.find(
+    ({ model }) => model.id === parsedCompactionSetting.modelId
+  ) : void 0;
   const preferredKey = activeRuntimeSnapshot ? activeRuntimeSnapshot.id : preferredVoiceModelEntry ? buildModelSelectionKey(
     preferredVoiceModelEntry.authType,
     preferredVoiceModelEntry.model.id,
@@ -11231,6 +11257,10 @@ function ModelDialog({
     preferredVisionModelEntry.authType,
     preferredVisionModelEntry.model.id,
     preferredVisionModelEntry.model.baseUrl
+  ) : preferredCompactionModelEntry ? buildModelSelectionKey(
+    preferredCompactionModelEntry.authType,
+    preferredCompactionModelEntry.model.id,
+    preferredCompactionModelEntry.model.baseUrl
   ) : preferredImageModelEntry ? buildModelSelectionKey(
     preferredImageModelEntry.authType,
     preferredImageModelEntry.model.id,
@@ -11246,7 +11276,7 @@ function ModelDialog({
   ) : "";
   useKeypress(
     (key) => {
-      if (key.name === "escape" || key.name === "left" && (isFastModelMode || isVoiceModelMode || isVisionModelMode || isImageModelMode)) {
+      if (key.name === "escape" || key.name === "left" && (isFastModelMode || isVoiceModelMode || isVisionModelMode || isCompactionModelMode || isImageModelMode)) {
         onClose();
       }
     },
@@ -11359,6 +11389,26 @@ ${t("\u26A0 '{{model}}' is not a known image-capable model; the vision bridge ma
         onClose();
         return;
       }
+      if (isCompactionModelMode) {
+        if (!selectedEntry || !config) {
+          setErrorMessage(t("Selected compaction model is unavailable."));
+          return;
+        }
+        const compactionModelId = encodeAuxModelSelector(selected);
+        const scope = resolvePersistScope(settings, persistScope);
+        settings.setValue(scope, "compactionModel", compactionModelId);
+        config.setCompactionModel(compactionModelId);
+        const scopeSuffix = persistScope === "workspace" ? t(" (this project)") : persistScope === "user" ? t(" (global)") : "";
+        uiState?.historyManager.addItem(
+          {
+            type: "success",
+            text: `${t("Compaction Model")}: ${compactionModelId}${scopeSuffix}`
+          },
+          Date.now()
+        );
+        onClose();
+        return;
+      }
       if (isImageModelMode) {
         if (!selectedEntry || !config) {
           setErrorMessage(t("Selected image model is unavailable."));
@@ -11476,6 +11526,7 @@ ${baseErrorMessage}`);
       isFastModelMode,
       isVoiceModelMode,
       isVisionModelMode,
+      isCompactionModelMode,
       isImageModelMode,
       availableModelEntries,
       persistScope
@@ -11491,7 +11542,7 @@ ${baseErrorMessage}`);
       padding: 1,
       width: "100%",
       children: [
-        /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Text, { bold: true, children: (isVoiceModelMode ? t("Select Voice Model") : isVisionModelMode ? t("Select Vision Model") : isImageModelMode ? t("Select Image Model") : isFastModelMode ? t("Select Fast Model") : t("Select Model")) + (persistScope === "workspace" ? t(" (this project)") : persistScope === "user" ? t(" (global)") : "") }),
+        /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Text, { bold: true, children: (isVoiceModelMode ? t("Select Voice Model") : isVisionModelMode ? t("Select Vision Model") : isCompactionModelMode ? t("Select Compaction Model") : isImageModelMode ? t("Select Image Model") : isFastModelMode ? t("Select Fast Model") : t("Select Model")) + (persistScope === "workspace" ? t(" (this project)") : persistScope === "user" ? t(" (global)") : "") }),
         !hasModels ? /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)(Box_default, { marginTop: 1, flexDirection: "column", children: [
           /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Text, { color: theme.status.warning, children: t(
             "No models available for the current authentication type ({{authType}}).",
@@ -24431,6 +24482,7 @@ var DialogManager = /* @__PURE__ */ __name(({
         isFastModelMode: uiState.isFastModelMode,
         isVoiceModelMode: uiState.isVoiceModelMode,
         isVisionModelMode: uiState.isVisionModelMode,
+        isCompactionModelMode: uiState.isCompactionModelMode,
         isImageModelMode: uiState.isImageModelMode,
         persistScope: uiState.modelDialogPersistScope,
         availableTerminalHeight: listDialogHeight
@@ -29189,9 +29241,8 @@ var InputPrompt = /* @__PURE__ */ __name(({
   const uiState = useUIState();
   const uiActions = useUIActions();
   const settings = useSettings();
-  const mouseInteractionsEnabled = useVirtualViewport(
-    settings.merged.ui?.useTerminalBuffer
-  );
+  const mouseTrackingEnabled = useMouseTrackingEnabled();
+  const mouseInteractionsEnabled = useVirtualViewport(settings.merged.ui?.useTerminalBuffer) && mouseTrackingEnabled;
   const { pasteWorkaround } = useKeypressContext();
   const { agents, agentTabBarFocused } = useAgentViewState();
   const { setAgentTabBarFocused } = useAgentViewActions();
@@ -31274,45 +31325,102 @@ __name(useConfigInitMessage, "useConfigInitMessage");
 init_esbuild_shims();
 var import_react103 = __toESM(require_react(), 1);
 var import_jsx_runtime114 = __toESM(require_jsx_runtime(), 1);
-var POLL_INTERVAL_MS = 1e3;
+var ELAPSED_REFRESH_MS = 1e3;
 function formatElapsed(ms) {
   if (ms < 1e3) return "";
-  const s = Math.floor(ms / 1e3);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m`;
-  const h = Math.floor(m / 60);
-  return `${h}h ${m % 60}m`;
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
 }
 __name(formatElapsed, "formatElapsed");
-function useActiveGoal(sessionId) {
-  const [goal, setGoal] = (0, import_react103.useState)(
-    () => getActiveGoal(sessionId)
-  );
-  const [, setTick] = (0, import_react103.useState)(0);
-  (0, import_react103.useEffect)(() => {
-    const id = setInterval(() => {
-      const next = getActiveGoal(sessionId);
-      setGoal(next);
-      if (next) setTick((t2) => (t2 + 1) % 1e6);
-    }, POLL_INTERVAL_MS);
-    return () => clearInterval(id);
-  }, [sessionId]);
-  return goal;
+function getRuntime(config) {
+  if (typeof config.getGoalRuntime !== "function") return null;
+  try {
+    return config.getGoalRuntime();
+  } catch {
+    return null;
+  }
 }
-__name(useActiveGoal, "useActiveGoal");
+__name(getRuntime, "getRuntime");
 function useFooterGoalState() {
   const config = useConfig();
-  return useActiveGoal(config.getSessionId());
+  const sessionId = config.getSessionId();
+  const runtime = getRuntime(config);
+  const [observed, setObserved] = (0, import_react103.useState)(() => ({
+    runtime,
+    snapshot: runtime?.getSnapshot()
+  }));
+  (0, import_react103.useEffect)(() => {
+    if (!runtime) {
+      setObserved({ runtime });
+      return;
+    }
+    setObserved({ runtime, snapshot: runtime.getSnapshot() });
+    return runtime.subscribe((snapshot) => {
+      setObserved({ runtime, snapshot });
+    });
+  }, [runtime, sessionId]);
+  return observed.runtime === runtime ? observed.snapshot : runtime?.getSnapshot();
 }
 __name(useFooterGoalState, "useFooterGoalState");
-var GoalPill = /* @__PURE__ */ __name(() => {
-  const goal = useFooterGoalState();
+function isLiveGoalSnapshot(snapshot) {
+  const status = snapshot?.goal?.status;
+  return status !== void 0 && status !== "complete";
+}
+__name(isLiveGoalSnapshot, "isLiveGoalSnapshot");
+function presentation(snapshot) {
+  const goal = snapshot.goal;
+  if (!goal || goal.status === "complete") return null;
+  if (goal.status === "active") {
+    return snapshot.activity === "verifying" ? {
+      icon: ICON.CIRCLE_EMPTY,
+      label: "checking",
+      color: theme.text.secondary
+    } : { icon: ICON.BULLSEYE, label: "active", color: theme.text.accent };
+  }
+  switch (goal.status) {
+    case "paused":
+      return { icon: "!", label: "paused", color: theme.status.warning };
+    case "blocked":
+      return { icon: ICON.CROSS, label: "blocked", color: theme.status.error };
+    case "usage_limited":
+      return {
+        icon: "!",
+        label: "usage limited",
+        color: theme.status.warning
+      };
+    default: {
+      const exhaustive = goal.status;
+      void exhaustive;
+      return null;
+    }
+  }
+}
+__name(presentation, "presentation");
+var GoalPill = /* @__PURE__ */ __name(({ snapshot }) => {
+  const [, setTick] = (0, import_react103.useState)(0);
+  const refreshElapsed = snapshot?.goal?.status === "active";
+  (0, import_react103.useEffect)(() => {
+    if (!refreshElapsed) return;
+    const interval = setInterval(() => {
+      setTick((tick) => (tick + 1) % 1e6);
+    }, ELAPSED_REFRESH_MS);
+    return () => clearInterval(interval);
+  }, [refreshElapsed]);
+  if (!snapshot) return null;
+  const goal = snapshot.goal;
   if (!goal) return null;
-  const elapsed = formatElapsed(Date.now() - goal.setAt);
+  const visible = presentation(snapshot);
+  if (!visible) return null;
+  const elapsed = formatElapsed(elapsedActiveTime(goal, Date.now()));
   const suffix = elapsed ? ` (${elapsed})` : "";
-  return /* @__PURE__ */ (0, import_jsx_runtime114.jsxs)(Text, { color: theme.text.accent, children: [
-    "\u25CE /goal active",
+  return /* @__PURE__ */ (0, import_jsx_runtime114.jsxs)(Text, { color: visible.color, children: [
+    visible.icon,
+    " /goal ",
+    visible.label,
     suffix
   ] });
 }, "GoalPill");
@@ -31321,7 +31429,7 @@ var GoalPill = /* @__PURE__ */ __name(() => {
 init_esbuild_shims();
 var import_react104 = __toESM(require_react(), 1);
 var import_jsx_runtime115 = __toESM(require_jsx_runtime(), 1);
-var POLL_INTERVAL_MS2 = 1e3;
+var POLL_INTERVAL_MS = 1e3;
 function getScheduledTaskCount(config) {
   if (!config?.isCronEnabled?.()) return 0;
   return config.getCronScheduler?.()?.size ?? 0;
@@ -31332,7 +31440,7 @@ function useScheduledTaskCount(config) {
   (0, import_react104.useEffect)(() => {
     const id = setInterval(() => {
       setCount(getScheduledTaskCount(config));
-    }, POLL_INTERVAL_MS2);
+    }, POLL_INTERVAL_MS);
     return () => clearInterval(id);
   }, [config]);
   return count;
@@ -31441,9 +31549,12 @@ var Footer = /* @__PURE__ */ __name(() => {
       ) })
     });
   }
-  const goalActive = useFooterGoalState() !== void 0;
-  if (goalActive) {
-    rightItems.push({ key: "goal", node: /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(GoalPill, {}) });
+  const goalState = useFooterGoalState();
+  if (isLiveGoalSnapshot(goalState)) {
+    rightItems.push({
+      key: "goal",
+      node: /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(GoalPill, { snapshot: goalState })
+    });
   }
   const cronTaskCount = useFooterCronTaskCount();
   if (cronTaskCount > 0) {
@@ -33608,20 +33719,25 @@ var useModelCommand = /* @__PURE__ */ __name(() => {
   const [isFastModelMode, setIsFastModelMode] = (0, import_react122.useState)(false);
   const [isVoiceModelMode, setIsVoiceModelMode] = (0, import_react122.useState)(false);
   const [isVisionModelMode, setIsVisionModelMode] = (0, import_react122.useState)(false);
+  const [isCompactionModelMode, setIsCompactionModelMode] = (0, import_react122.useState)(false);
   const [isImageModelMode, setIsImageModelMode] = (0, import_react122.useState)(false);
   const [modelDialogPersistScope, setModelDialogPersistScope] = (0, import_react122.useState)(void 0);
   const openModelDialog = (0, import_react122.useCallback)(
     (options) => {
       const voiceModelMode = options?.voiceModelMode ?? false;
       const visionModelMode = options?.visionModelMode ?? false;
+      const compactionModelMode = options?.compactionModelMode ?? false;
       const imageModelMode = options?.imageModelMode ?? false;
       setIsFastModelMode(
-        voiceModelMode || visionModelMode || imageModelMode ? false : options?.fastModelMode ?? false
+        voiceModelMode || visionModelMode || compactionModelMode || imageModelMode ? false : options?.fastModelMode ?? false
       );
       setIsVoiceModelMode(
-        visionModelMode || imageModelMode ? false : voiceModelMode
+        visionModelMode || compactionModelMode || imageModelMode ? false : voiceModelMode
+      );
+      setIsVisionModelMode(
+        compactionModelMode || imageModelMode ? false : visionModelMode
       );
-      setIsVisionModelMode(imageModelMode ? false : visionModelMode);
+      setIsCompactionModelMode(imageModelMode ? false : compactionModelMode);
       setIsImageModelMode(imageModelMode);
       setModelDialogPersistScope(options?.persistScope);
       setIsModelDialogOpen(true);
@@ -33633,6 +33749,7 @@ var useModelCommand = /* @__PURE__ */ __name(() => {
     setIsFastModelMode(false);
     setIsVoiceModelMode(false);
     setIsVisionModelMode(false);
+    setIsCompactionModelMode(false);
     setIsImageModelMode(false);
     setModelDialogPersistScope(void 0);
   }, []);
@@ -33641,6 +33758,7 @@ var useModelCommand = /* @__PURE__ */ __name(() => {
     isFastModelMode,
     isVoiceModelMode,
     isVisionModelMode,
+    isCompactionModelMode,
     isImageModelMode,
     modelDialogPersistScope,
     openModelDialog,
@@ -33814,6 +33932,7 @@ function useBranchCommand(options) {
         }
         config.startNewSession(newSessionId, resumed);
         coreSwapped = true;
+        await waitForGoalRuntime(config);
         await config.getGeminiClient()?.initialize?.("branch" /* Branch */);
         const rawItems = buildResumedHistoryItems(resumed, config);
         const collapseOnResume = options.settings.merged.ui?.history?.collapseOnResume ?? false;
@@ -33828,14 +33947,6 @@ function useBranchCommand(options) {
         historyManager.loadHistory(uiHistoryItems);
         uiSwapped = true;
         resetBackgroundStateForSessionSwitch(config);
-        try {
-          restoreGoalFromHistory(
-            uiHistoryItems,
-            config,
-            historyManager.addItem
-          );
-        } catch {
-        }
         setSessionName?.(effectiveTitle);
         remount?.();
         const titleInfo = name ? ` "${name}"` : "";
@@ -33979,10 +34090,7 @@ function useResumeCommand(options) {
         resetBackgroundStateForSessionSwitch(config);
         config.startNewSession(sessionId, sessionData);
         coreSwapped = true;
-        try {
-          restoreGoalFromHistory(uiHistoryItems, config, addItem);
-        } catch {
-        }
+        await waitForGoalRuntime(config);
         config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
         await config.getGeminiClient()?.initialize?.();
         const recovered = await config.loadPausedBackgroundAgents(sessionId);
@@ -35023,6 +35131,29 @@ var useSlashCommandProcessor = /* @__PURE__ */ __name((config, settings, history
                     });
                   }
                   return { type: "handled" };
+                case "goal_control": {
+                  const rendersHere = result.cause === void 0 || commandContext.ui.isIdleRef.current;
+                  if (rendersHere) {
+                    const snapshot = result.response.snapshot;
+                    if (snapshot.goal || result.cause === "clear") {
+                      addItem(
+                        {
+                          type: "goal_state" /* GOAL_STATE */,
+                          snapshot,
+                          ...result.cause ? { cause: result.cause } : {}
+                        },
+                        Date.now()
+                      );
+                    } else {
+                      addMessage({
+                        type: "info" /* INFO */,
+                        content: "No Goal set.",
+                        timestamp: /* @__PURE__ */ new Date()
+                      });
+                    }
+                  }
+                  return { type: "handled" };
+                }
                 case "dialog":
                   switch (result.dialog) {
                     case "arena_start":
@@ -35078,6 +35209,12 @@ var useSlashCommandProcessor = /* @__PURE__ */ __name((config, settings, history
                         persistScope: result.persistScope
                       });
                       return { type: "handled" };
+                    case "compaction-model":
+                      actions.openModelDialog({
+                        compactionModelMode: true,
+                        persistScope: result.persistScope
+                      });
+                      return { type: "handled" };
                     case "image-model":
                       actions.openModelDialog({
                         imageModelMode: true,
@@ -36110,85 +36247,201 @@ import process15 from "node:process";
 // packages/cli/src/ui/hooks/useMessageQueue.ts
 init_esbuild_shims();
 var import_react134 = __toESM(require_react(), 1);
+import { randomUUID as randomUUID2 } from "node:crypto";
 var GOAL_COMMAND_RE = /^\/goal(?:\s|$)/;
-function aggregateMessages(messages) {
-  const modelText = messages.map((message) => message.modelText).join("\n\n");
+function aggregateUserMessages(messages) {
+  const text = messages.map((message) => message.text).join("\n\n");
   const submittedPrompts = messages.map((message) => message.submittedPrompt);
-  return submittedPrompts.every(
-    (submittedPrompt) => submittedPrompt !== void 0
-  ) ? { modelText, submittedPrompt: submittedPrompts.join("\n\n") } : { modelText };
+  return {
+    kind: "user",
+    modelText: text,
+    turnKey: messages[0].key,
+    ...submittedPrompts.every(
+      (submittedPrompt) => submittedPrompt !== void 0
+    ) ? { submittedPrompt: submittedPrompts.join("\n\n") } : {}
+  };
 }
-__name(aggregateMessages, "aggregateMessages");
+__name(aggregateUserMessages, "aggregateUserMessages");
 function useMessageQueue() {
   const [queuedMessages, setQueuedMessages] = (0, import_react134.useState)([]);
+  const [queuedGoalTurns, setQueuedGoalTurns] = (0, import_react134.useState)([]);
   const queueRef = (0, import_react134.useRef)([]);
+  const goalQueueRef = (0, import_react134.useRef)([]);
+  const nextMessageKey = (0, import_react134.useCallback)(() => `message-queue:${randomUUID2()}`, []);
   const addMessage = (0, import_react134.useCallback)(
     (message, deferUntilIdle = false, submittedPrompt) => {
-      const modelText = message.trim();
-      if (modelText.length > 0) {
-        queueRef.current = [
-          ...queueRef.current,
-          { modelText, deferUntilIdle, submittedPrompt }
-        ];
-        setQueuedMessages(queueRef.current);
+      const text = message.trim();
+      if (!text) return;
+      queueRef.current = [
+        ...queueRef.current,
+        {
+          key: nextMessageKey(),
+          text,
+          deferUntilIdle,
+          submittedPrompt
+        }
+      ];
+      setQueuedMessages(queueRef.current);
+    },
+    [nextMessageKey]
+  );
+  const enqueueGoalTurn = (0, import_react134.useCallback)(
+    (input) => {
+      if (goalQueueRef.current.some(
+        ({ permit }) => permit.turnId === input.permit.turnId
+      )) {
+        return;
       }
+      const entry = {
+        kind: "goal",
+        permit: { ...input.permit },
+        turnKey: `goal-runtime:${input.permit.turnId}`,
+        continuationContext: input.continuationContext,
+        ...input.verifierFeedback ? { verifierFeedback: input.verifierFeedback } : {}
+      };
+      goalQueueRef.current = [...goalQueueRef.current, entry];
+      setQueuedGoalTurns(goalQueueRef.current);
     },
     []
   );
+  const peekNextUserBatchKey = (0, import_react134.useCallback)(
+    (goalTurnActive = false) => goalTurnActive ? void 0 : queueRef.current.find(({ text }) => !isSlashCommand(text))?.key,
+    []
+  );
+  const hasQueuedUserMessages = (0, import_react134.useCallback)(
+    () => queueRef.current.length > 0,
+    []
+  );
+  const getPendingSubmissionCount = (0, import_react134.useCallback)(
+    () => queueRef.current.length + goalQueueRef.current.length,
+    []
+  );
+  const claimGoalTurn = (0, import_react134.useCallback)(() => {
+    const [goal, ...remainingGoals] = goalQueueRef.current;
+    if (goal) {
+      goalQueueRef.current = remainingGoals;
+      setQueuedGoalTurns(remainingGoals);
+    }
+    return goal;
+  }, []);
+  const claimDirectUserAdmission = (0, import_react134.useCallback)(() => {
+    const goal = claimGoalTurn();
+    return {
+      turnKey: nextMessageKey(),
+      ...goal ? { goal } : {}
+    };
+  }, [claimGoalTurn, nextMessageKey]);
+  const removeGoalTurns = (0, import_react134.useCallback)(() => {
+    const keys = goalQueueRef.current.map(({ turnKey }) => turnKey);
+    if (keys.length === 0) return [];
+    goalQueueRef.current = [];
+    setQueuedGoalTurns([]);
+    return keys;
+  }, []);
+  const popNextSubmission = (0, import_react134.useCallback)(
+    (goalControlMode = "normal") => {
+      if (goalControlMode !== "normal") {
+        const goalCommandIndex = queueRef.current.findIndex(
+          ({ text }) => GOAL_COMMAND_RE.test(text)
+        );
+        if (goalCommandIndex >= 0) {
+          const goalCommand = queueRef.current[goalCommandIndex];
+          queueRef.current = [
+            ...queueRef.current.slice(0, goalCommandIndex),
+            ...queueRef.current.slice(goalCommandIndex + 1)
+          ];
+          setQueuedMessages(queueRef.current);
+          return aggregateUserMessages([goalCommand]);
+        }
+        if (goalControlMode === "priority") {
+          return claimGoalTurn() ?? null;
+        }
+        if (goalControlMode === "only") return null;
+      }
+      const plainMessages = queueRef.current.filter(
+        ({ text }) => !isSlashCommand(text)
+      );
+      if (plainMessages.length > 0) {
+        queueRef.current = queueRef.current.filter(
+          ({ text }) => isSlashCommand(text)
+        );
+        setQueuedMessages(queueRef.current);
+        return aggregateUserMessages(plainMessages);
+      }
+      const [userHead, ...userRest] = queueRef.current;
+      if (userHead) {
+        queueRef.current = userRest;
+        setQueuedMessages(userRest);
+        return aggregateUserMessages([userHead]);
+      }
+      return claimGoalTurn() ?? null;
+    },
+    [claimGoalTurn]
+  );
   const clearQueue = (0, import_react134.useCallback)(() => {
     queueRef.current = [];
     setQueuedMessages([]);
   }, []);
   const getQueuedMessagesText = (0, import_react134.useCallback)(() => {
     if (queuedMessages.length === 0) return "";
-    return queuedMessages.map(({ modelText }) => modelText).join("\n\n");
+    return queuedMessages.map(({ text }) => text).join("\n\n");
   }, [queuedMessages]);
-  const popAllMessages = (0, import_react134.useCallback)(() => {
-    const current = queueRef.current;
-    if (current.length === 0) return null;
-    queueRef.current = [];
-    setQueuedMessages([]);
-    return aggregateMessages(current);
-  }, []);
-  const restoreMessages = (0, import_react134.useCallback)((messages) => {
-    const restored = messages.map((text) => text.trim()).filter(Boolean).map((modelText) => ({ modelText, deferUntilIdle: false }));
-    if (restored.length === 0) return;
-    queueRef.current = [...restored, ...queueRef.current];
-    setQueuedMessages(queueRef.current);
-  }, []);
-  const drainQueue = (0, import_react134.useCallback)((includeDeferred = false) => {
-    const current = queueRef.current;
-    if (current.length === 0) return [];
-    const shouldDrain = /* @__PURE__ */ __name((message) => (!isSlashCommand(message.modelText) || !includeDeferred && GOAL_COMMAND_RE.test(message.modelText)) && (includeDeferred || !message.deferUntilIdle), "shouldDrain");
-    const drained = current.filter(shouldDrain);
-    if (drained.length === 0) return [];
-    const rest = current.filter((message) => !shouldDrain(message));
-    queueRef.current = rest;
-    setQueuedMessages(rest);
-    return drained.map(({ modelText }) => modelText);
-  }, []);
-  const popNextTurn = (0, import_react134.useCallback)(() => {
-    const current = queueRef.current;
-    if (current.length === 0) return null;
-    const plainMessages = current.filter(
-      (message) => !isSlashCommand(message.modelText)
-    );
-    const messages = plainMessages.length > 0 ? plainMessages : [current[0]];
-    const selected = new Set(messages);
-    const rest = current.filter((message) => !selected.has(message));
-    queueRef.current = rest;
-    setQueuedMessages(rest);
-    return aggregateMessages(messages);
-  }, []);
+  const popAllMessages = (0, import_react134.useCallback)(
+    (onRemoved) => {
+      const current = queueRef.current;
+      if (current.length === 0) return null;
+      queueRef.current = [];
+      setQueuedMessages([]);
+      onRemoved?.(current.map(({ key }) => key));
+      return aggregateUserMessages(current);
+    },
+    []
+  );
+  const restoreMessages = (0, import_react134.useCallback)(
+    (messages, submittedPrompt) => {
+      const restored = messages.map((text) => text.trim()).filter(Boolean).map((text) => ({
+        key: nextMessageKey(),
+        text,
+        ...messages.length === 1 && submittedPrompt !== void 0 ? { submittedPrompt } : {},
+        deferUntilIdle: false
+      }));
+      if (restored.length === 0) return;
+      queueRef.current = [...restored, ...queueRef.current];
+      setQueuedMessages(queueRef.current);
+    },
+    [nextMessageKey]
+  );
+  const drainQueue = (0, import_react134.useCallback)(
+    (includeDeferred = false, goalTurnActive = false) => {
+      const current = queueRef.current;
+      if (current.length === 0) return [];
+      const shouldDrain = /* @__PURE__ */ __name((message) => (goalTurnActive ? GOAL_COMMAND_RE.test(message.text) : !isSlashCommand(message.text)) && (includeDeferred || !message.deferUntilIdle), "shouldDrain");
+      const drained = current.filter(shouldDrain);
+      if (drained.length === 0) return [];
+      const rest = current.filter((message) => !shouldDrain(message));
+      queueRef.current = rest;
+      setQueuedMessages(rest);
+      return drained.map(({ text }) => text);
+    },
+    []
+  );
   return {
-    messageQueue: queuedMessages.map(({ modelText }) => modelText),
+    messageQueue: queuedMessages.map(({ text }) => text),
+    pendingSubmissionCount: queuedMessages.length + queuedGoalTurns.length,
     addMessage,
+    enqueueGoalTurn,
+    peekNextUserBatchKey,
+    hasQueuedUserMessages,
+    getPendingSubmissionCount,
+    claimGoalTurn,
+    claimDirectUserAdmission,
+    removeGoalTurns,
+    popNextSubmission,
     clearQueue,
     getQueuedMessagesText,
     popAllMessages,
     restoreMessages,
-    drainQueue,
-    popNextTurn
+    drainQueue
   };
 }
 __name(useMessageQueue, "useMessageQueue");
@@ -36209,6 +36462,19 @@ function clearModelOverride(modelOverrideRef, inlineActiveRef) {
 __name(clearModelOverride, "clearModelOverride");
 var MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MS = 1e4;
 var MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MESSAGE = "Mid-turn @ command resolution timed out";
+function sameGoalPermit(left, right) {
+  return left.goalId === right.goalId && left.revision === right.revision && left.turnId === right.turnId;
+}
+__name(sameGoalPermit, "sameGoalPermit");
+function sharedGoalPermit(contexts) {
+  const first = contexts[0];
+  if (contexts.every((context) => context === void 0)) return void 0;
+  if (!first || contexts.some((context) => !context || !sameGoalPermit(first, context))) {
+    throw new Error("ToolResult batch has mixed Goal contexts");
+  }
+  return { ...first };
+}
+__name(sharedGoalPermit, "sharedGoalPermit");
 function extractLastAssistantText(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     const item = history[i];
@@ -36335,17 +36601,120 @@ function charIndexAfterLine(text, keptLines) {
   return -1;
 }
 __name(charIndexAfterLine, "charIndexAfterLine");
-var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config, isConfigInitialized, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, midTurnDrainRef, logger, availableTerminalHeightRef, terminalWidthRef, midTurnRestoreRef) => {
+var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config, isConfigInitialized, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, midTurnDrainRef, logger, availableTerminalHeightRef, terminalWidthRef, midTurnRestoreRef, goalQueueRef) => {
   const [initError, setInitError] = (0, import_react135.useState)(null);
   const abortControllerRef = (0, import_react135.useRef)(null);
+  const activeGoalTurnRef = (0, import_react135.useRef)(null);
+  const activeGoalAdmissionRef = (0, import_react135.useRef)(null);
+  const goalTurnBindingsRef = (0, import_react135.useRef)(/* @__PURE__ */ new Map());
+  const bindGoalTurn = (0, import_react135.useCallback)(
+    (permit, turnKey, origin, controller = new AbortController()) => {
+      const existing = goalTurnBindingsRef.current.get(permit.turnId);
+      if (existing && existing.turnKey === turnKey && sameGoalPermit(existing.permit, permit) && !existing.controller.signal.aborted) {
+        activeGoalTurnRef.current = existing;
+        activeGoalAdmissionRef.current = existing;
+        return existing;
+      }
+      const binding = {
+        permit: { ...permit },
+        turnKey,
+        controller,
+        origin
+      };
+      goalTurnBindingsRef.current.set(permit.turnId, binding);
+      activeGoalTurnRef.current = binding;
+      activeGoalAdmissionRef.current = binding;
+      return binding;
+    },
+    []
+  );
+  const releaseGoalTurn = (0, import_react135.useCallback)((binding) => {
+    if (goalTurnBindingsRef.current.get(binding.permit.turnId) === binding) {
+      goalTurnBindingsRef.current.delete(binding.permit.turnId);
+    }
+    if (activeGoalTurnRef.current === binding) {
+      activeGoalTurnRef.current = null;
+    }
+    if (activeGoalAdmissionRef.current?.controller === binding.controller && activeGoalAdmissionRef.current.turnKey === binding.turnKey) {
+      activeGoalAdmissionRef.current = null;
+    }
+  }, []);
+  const failClosedGoalTurn = (0, import_react135.useCallback)(
+    async (binding, reason) => {
+      if (!binding.controller.signal.aborted) {
+        binding.controller.abort(reason);
+      }
+      try {
+        const runtime = await config.getGoalRuntimeReady();
+        const admittedPermit = runtime.permitForTurn(binding.turnKey);
+        if (!admittedPermit || !sameGoalPermit(admittedPermit, binding.permit)) {
+          return;
+        }
+        if (runtime.getSnapshot().goal?.status === "active") {
+          try {
+            await runtime.dispatch({
+              action: "pause",
+              expectedGoalId: binding.permit.goalId,
+              expectedRevision: binding.permit.revision
+            });
+          } catch (error) {
+            debugLogger36.warn("Failed to pause invalid Goal tool batch", error);
+          }
+        }
+        try {
+          await config.getChatRecordingService()?.flush();
+        } catch (error) {
+          debugLogger36.warn("Failed to flush invalid Goal tool batch", error);
+        }
+        const currentPermit = runtime.permitForTurn(binding.turnKey);
+        if (currentPermit && sameGoalPermit(currentPermit, binding.permit)) {
+          await runtime.finishTurn(binding.permit);
+        }
+      } catch (error) {
+        debugLogger36.warn("Failed to close invalid Goal tool batch", error);
+      } finally {
+        releaseGoalTurn(binding);
+      }
+    },
+    [config, releaseGoalTurn]
+  );
+  const releaseUndeliveredGoalTurn = (0, import_react135.useCallback)(
+    async (turnKey) => {
+      if (!turnKey) return;
+      try {
+        const runtime = await config.getGoalRuntimeReady();
+        await runtime.releaseTurn(turnKey);
+      } catch (error) {
+        debugLogger36.warn(
+          `Failed to release undelivered Goal turn ${turnKey}`,
+          error
+        );
+      }
+    },
+    [config]
+  );
   const flushBufferedStreamEventsRef = (0, import_react135.useRef)(/* @__PURE__ */ new Set());
   const turnCancelledRef = (0, import_react135.useRef)(false);
   const isSubmittingQueryRef = (0, import_react135.useRef)(false);
+  const submissionLeaseGenerationRef = (0, import_react135.useRef)(0);
+  const setSubmissionInFlight = (0, import_react135.useCallback)(
+    (inFlight) => {
+      const changed = isSubmittingQueryRef.current !== inFlight;
+      isSubmittingQueryRef.current = inFlight;
+      const sharedRef = goalQueueRef?.current?.submissionInFlightRef;
+      if (sharedRef) sharedRef.current = inFlight;
+      if (changed && !inFlight) {
+        goalQueueRef?.current?.onSubmissionSettled?.();
+      }
+    },
+    [goalQueueRef]
+  );
   const lastPromptRef = (0, import_react135.useRef)(null);
   const lastTurnUserItemRef = (0, import_react135.useRef)(null);
   const canUndoLastLoggedUserMessageRef = (0, import_react135.useRef)(false);
   const turnSawContentEventRef = (0, import_react135.useRef)(false);
   const lastPromptErroredRef = (0, import_react135.useRef)(false);
+  const goalTerminalErrorRef = (0, import_react135.useRef)(false);
   const commitItem = (0, import_react135.useCallback)(
     (item, userMessageTimestamp) => {
       if (item.type === "gemini" && !item.timestamp) {
@@ -36562,7 +36931,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     }
     const pendingItemAtCancel = pendingHistoryItemRef.current;
     turnCancelledRef.current = true;
-    isSubmittingQueryRef.current = false;
+    submissionLeaseGenerationRef.current += 1;
+    setSubmissionInFlight(false);
     abortControllerRef.current?.abort();
     const loopWakeupsCancelled = config.getCronScheduler()?.cancelAllWakeups() ?? 0;
     for (const ac of auxiliaryAbortRefsRef.current) {
@@ -36604,7 +36974,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         pendingItem: pendingItemAtCancel,
         lastTurnUserItem: lastTurnUserItemRef.current,
         canUndoLastLoggedUserMessage: canUndoLastLoggedUserMessageRef.current,
-        turnProducedMeaningfulContent: turnSawContentEventRef.current
+        turnProducedMeaningfulContent: turnSawContentEventRef.current,
+        wasGoalTurn: activeGoalTurnRef.current !== null
       });
     } finally {
       setIsResponding(false);
@@ -36620,7 +36991,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     setShellInputFocused,
     clearRetryCountdown,
     config,
-    getPromptCount
+    getPromptCount,
+    setSubmissionInFlight
   ]);
   const applyVisionBridgeIfNeeded = (0, import_react135.useCallback)(
     async (parts, timestamp, signal) => {
@@ -37115,8 +37487,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     ]
   );
   const handleErrorEvent = (0, import_react135.useCallback)(
-    (eventValue, userMessageTimestamp) => {
-      lastPromptErroredRef.current = true;
+    (eventValue, userMessageTimestamp, submitType) => {
+      if (submitType !== "goal" /* Goal */) {
+        lastPromptErroredRef.current = true;
+      } else {
+        goalTerminalErrorRef.current = true;
+      }
       commitPendingThought(userMessageTimestamp);
       if (pendingHistoryItemRef.current) {
         commitItem(pendingHistoryItemRef.current, userMessageTimestamp);
@@ -37129,7 +37505,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         config.getContentGeneratorConfig()?.authType
       );
       if (!isShowingAutoRetry) {
-        const retryHint = t("Press Ctrl+Y to retry");
+        const retryHint = submitType !== "goal" /* Goal */ ? t("Press Ctrl+Y to retry") : void 0;
         setPendingRetryErrorItem({
           type: "error",
           text: formattedErrorText,
@@ -37227,10 +37603,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       }
       const activeModel = modelOverrideRef.current ?? config.getModel();
       const reasonClause = eventValue?.triggerReason === "image_overflow" ? `accumulated enough tool screenshots to trigger compaction for ${activeModel}` : `approached the input token limit for ${activeModel}`;
+      const warningSuffix = eventValue?.warning ? `
+\u26A0\uFE0F ${eventValue.warning}` : "";
       return addItem(
         {
           type: "info",
-          text: `IMPORTANT: This conversation ${reasonClause}. A compressed context will be sent for future messages (compressed from: ${eventValue?.originalTokenCount ?? "unknown"} to ${eventValue?.newTokenCount ?? "unknown"} tokens).`
+          text: `IMPORTANT: This conversation ${reasonClause}. A compressed context will be sent for future messages (compressed from: ${eventValue?.originalTokenCount ?? "unknown"} to ${eventValue?.newTokenCount ?? "unknown"} tokens).` + warningSuffix
         },
         Date.now()
       );
@@ -37314,22 +37692,6 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         commitItem(pendingHistoryItemRef.current, userMessageTimestamp);
         setPendingHistoryItem(null);
       }
-      const activeGoal = getActiveGoal(config.getSessionId());
-      if (activeGoal && activeGoal.condition) {
-        const item = {
-          type: "goal_status" /* GOAL_STATUS */,
-          kind: "checking",
-          condition: activeGoal.condition,
-          iterations: activeGoal.iterations,
-          // Carried so a transcript truncated past its `set` card can still
-          // restore the goal's original start time.
-          setAt: activeGoal.setAt,
-          lastReason: activeGoal.lastReason ?? value.reasons[value.reasons.length - 1]
-        };
-        addItem(item, userMessageTimestamp);
-        recordGoalStatusItem(config, item);
-        return;
-      }
       addItem(
         {
           type: "stop_hook_loop",
@@ -37340,30 +37702,13 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         userMessageTimestamp
       );
     },
-    [addItem, commitItem, config, pendingHistoryItemRef, setPendingHistoryItem]
-  );
-  const handleActiveGoalEvent = (0, import_react135.useCallback)(
-    (activeGoal) => {
-      const sessionId = config.getSessionId();
-      const currentActiveGoal = getActiveGoal(sessionId);
-      if (activeGoal) {
-        if (activeGoalEquals(currentActiveGoal, activeGoal)) {
-          return;
-        }
-        setActiveGoal(sessionId, activeGoal);
-        return;
-      }
-      if (!currentActiveGoal) {
-        return;
-      }
-      clearActiveGoal(sessionId);
-    },
-    [config]
+    [addItem, commitItem, pendingHistoryItemRef, setPendingHistoryItem]
   );
   const processGeminiStreamEvents = (0, import_react135.useCallback)(
-    async (stream, userMessageTimestamp, signal) => {
+    async (stream, userMessageTimestamp, signal, submitType, turnAdmission) => {
       let geminiMessageBuffer = "";
       let thoughtBuffer = "";
+      let scheduledToolContinuation = false;
       const toolCallRequests = [];
       const bufferedEvents = [];
       let flushTimer = null;
@@ -37463,6 +37808,14 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
               commitPendingThought(userMessageTimestamp);
               thoughtBuffer = "";
               setThought((prev) => prev ? null : prev);
+              if (event.value.goalContext && turnAdmission) {
+                bindGoalTurn(
+                  event.value.goalContext,
+                  turnAdmission.turnKey,
+                  turnAdmission.origin,
+                  turnAdmission.controller
+                );
+              }
               toolCallRequests.push(event.value);
               try {
                 const argsJson = JSON.stringify(event.value.args);
@@ -37474,10 +37827,13 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
               flushBufferedStreamEvents();
               toolCallRequests.length = 0;
               handleUserCancelledEvent(userMessageTimestamp);
-              return 1 /* UserCancelled */;
+              return {
+                status: 1 /* UserCancelled */,
+                scheduledToolContinuation: false
+              };
             case "error" /* Error */:
               flushBufferedStreamEvents();
-              handleErrorEvent(event.value, userMessageTimestamp);
+              handleErrorEvent(event.value, userMessageTimestamp, submitType);
               break;
             case "chat_compressed" /* ChatCompressed */:
               flushBufferedStreamEvents();
@@ -37586,9 +37942,26 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
               handleStopHookLoopEvent(event.value, userMessageTimestamp);
               break;
             case "active_goal" /* ActiveGoal */:
-              handleActiveGoalEvent(event.value);
               break;
             case "goal_state" /* GoalState */:
+              if (event.cause && shouldDisplayGoalStateCause(event.cause)) {
+                flushBufferedStreamEvents();
+                if (pendingHistoryItemRef.current) {
+                  commitItem(
+                    pendingHistoryItemRef.current,
+                    userMessageTimestamp
+                  );
+                  setPendingHistoryItem(null);
+                }
+                addItem(
+                  {
+                    type: "goal_state",
+                    snapshot: event.value,
+                    cause: event.cause
+                  },
+                  userMessageTimestamp
+                );
+              }
               break;
             default: {
               const unreachable = event;
@@ -37623,7 +37996,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             `[processGeminiStreamEvents] Dropping batch after repeated duplicate provider tool-call id: ${repeatedDuplicateRequest.providerCallId} (tool: ${repeatedDuplicateRequest.name})`
           );
           loopDetectedRef.current = true;
-          return 0 /* Completed */;
+          return {
+            status: 0 /* Completed */,
+            scheduledToolContinuation: false
+          };
         }
         for (const request of toolCallRequests) {
           const providerCallId = request.providerCallId;
@@ -37666,6 +38042,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           }
         }
         if (executableToolCallRequests.length > 0) {
+          scheduledToolContinuation = true;
           scheduleToolCalls(
             executableToolCallRequests,
             signal,
@@ -37673,7 +38050,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           );
         }
       }
-      return 0 /* Completed */;
+      return {
+        status: 0 /* Completed */,
+        scheduledToolContinuation
+      };
     },
     [
       handleContentEvent,
@@ -37696,7 +38076,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       setPendingHistoryItem,
       handleUserPromptSubmitBlockedEvent,
       handleStopHookLoopEvent,
-      handleActiveGoalEvent,
+      bindGoalTurn,
       addItem,
       commitItem,
       dualOutput
@@ -37707,7 +38087,6 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       const resolvedSegments = [];
       const resolvedForRecording = [];
       const restoreMessages = [];
-      let pendingGoalSegmentIndex;
       const timestamp = Date.now();
       for (let index = 0; index < messages.length; index += 1) {
         if (signal.aborted) {
@@ -37716,21 +38095,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         }
         const message = messages[index];
         if (GOAL_COMMAND_RE.test(message)) {
-          const activeGoalBeforeCommand = getActiveGoal(config.getSessionId());
-          const result = await handleSlashCommand(message);
-          const activeGoalAfterCommand = getActiveGoal(config.getSessionId());
-          if (result && result.type === "submit_prompt") {
-            if (pendingGoalSegmentIndex !== void 0) {
-              resolvedSegments[pendingGoalSegmentIndex] = [];
-            }
-            pendingGoalSegmentIndex = resolvedSegments.length;
-            resolvedSegments.push(normalizePartList(result.content));
-          } else if (activeGoalBeforeCommand?.hookId !== activeGoalAfterCommand?.hookId) {
-            if (pendingGoalSegmentIndex !== void 0) {
-              resolvedSegments[pendingGoalSegmentIndex] = [];
-              pendingGoalSegmentIndex = void 0;
-            }
-          }
+          await handleSlashCommand(message);
           continue;
         }
         restoreMessages.push(message);
@@ -37849,7 +38214,13 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         accept: /* @__PURE__ */ __name(() => {
           for (const { message, parts, sideEffects } of resolvedForRecording) {
             for (const sideEffect of sideEffects) sideEffect();
-            config.getChatRecordingService?.()?.recordMidTurnUserMessage(parts, message);
+            const recorder = config.getChatRecordingService?.();
+            const goalPermit = activeGoalTurnRef.current?.permit;
+            if (goalPermit) {
+              recorder?.recordMidTurnUserMessage(parts, message, goalPermit);
+            } else {
+              recorder?.recordMidTurnUserMessage(parts, message);
+            }
             addItem(
               {
                 type: "user" /* USER */,
@@ -37910,7 +38281,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   );
   const drainSteerAtBoundary = (0, import_react135.useCallback)(
     async (signal) => {
-      const messages = midTurnDrainRef?.current?.() ?? [];
+      const messages = midTurnDrainRef?.current?.(
+        false,
+        Boolean(activeGoalAdmissionRef.current)
+      ) ?? [];
       if (messages.length === 0) return void 0;
       return resolveDrainedSteerMessages(messages, signal);
     },
@@ -37918,18 +38292,39 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   );
   const submitQuery = (0, import_react135.useCallback)(
     async (query, submitType = "userQuery" /* UserQuery */, prompt_id, metadata) => {
-      const allowConcurrentBtwDuringResponse = submitType === "userQuery" /* UserQuery */ && streamingState === "responding" /* Responding */ && typeof query === "string" && isBtwCommand(query);
+      const allowConcurrentBtwDuringResponse = submitType === "userQuery" /* UserQuery */ && streamingState === "responding" /* Responding */ && typeof query === "string" && isBtwCommand(query) && !activeGoalAdmissionRef.current;
+      let ownsSubmissionLease = false;
+      let submissionLeaseGeneration;
+      const acquireSubmissionLease = /* @__PURE__ */ __name(() => {
+        if (isSubmittingQueryRef.current) return;
+        ownsSubmissionLease = true;
+        submissionLeaseGeneration = submissionLeaseGenerationRef.current + 1;
+        submissionLeaseGenerationRef.current = submissionLeaseGeneration;
+        setSubmissionInFlight(true);
+      }, "acquireSubmissionLease");
+      const releaseSubmissionLease = /* @__PURE__ */ __name(() => {
+        if (!ownsSubmissionLease) return;
+        ownsSubmissionLease = false;
+        if (submissionLeaseGeneration !== submissionLeaseGenerationRef.current) {
+          return;
+        }
+        setSubmissionInFlight(false);
+      }, "releaseSubmissionLease");
       const isTurnContinuation = submitType === "toolResult" /* ToolResult */ || submitType === "steer" /* Steer */;
       const submittedPrompt = submitType === "userQuery" /* UserQuery */ ? metadata?.submittedPrompt : void 0;
       if (isSubmittingQueryRef.current && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
+        await releaseUndeliveredGoalTurn(metadata?.userAdmission?.turnKey);
+        metadata?.onAdmissionFailed?.();
         metadata?.onDeliveryFailed?.();
         return;
       }
       if ((streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */) && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
+        await releaseUndeliveredGoalTurn(metadata?.userAdmission?.turnKey);
+        metadata?.onAdmissionFailed?.();
         metadata?.onDeliveryFailed?.();
         return;
       }
-      isSubmittingQueryRef.current = true;
+      acquireSubmissionLease();
       loopDetectedRef.current = false;
       if (!isTurnContinuation && !allowConcurrentBtwDuringResponse) {
         lastTurnUserItemRef.current = null;
@@ -37941,7 +38336,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         immediateDuplicateToolResponsesRef.current = null;
       }
       const userMessageTimestamp = Date.now();
-      if (!isTurnContinuation && submitType !== "notification" /* Notification */ && !allowConcurrentBtwDuringResponse) {
+      if (!isTurnContinuation && submitType !== "notification" /* Notification */ && submitType !== "goal" /* Goal */ && !allowConcurrentBtwDuringResponse) {
         setModelSwitchedFromQuotaError(false);
         const droppingInlineOverrideOnRetry = submitType === "retry" /* Retry */ && inlineModelOverrideActiveRef.current;
         if (submitType !== "retry" /* Retry */ || inlineModelOverrideActiveRef.current) {
@@ -37975,20 +38370,87 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         prompt_id = config.getSessionId() + "########" + getPromptCount();
       }
       return promptIdContext.run(prompt_id, async () => {
-        const { queryToSend, shouldProceed } = submitType === "retry" /* Retry */ ? { queryToSend: query, shouldProceed: true } : await prepareQueryForGemini(
-          query,
-          userMessageTimestamp,
-          abortSignal,
-          prompt_id,
-          submitType,
-          submittedPrompt,
-          allowConcurrentBtwDuringResponse
-        );
+        let queuedGoal = metadata?.goal;
+        let preparedQuery;
+        try {
+          preparedQuery = submitType === "goal" /* Goal */ ? queuedGoal ? {
+            queryToSend: [
+              "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.",
+              "This is a synthetic continuation turn. It contains no new real user input and cannot satisfy an objective condition that requires the user to send, confirm, choose, approve, or provide something.",
+              "A phrase mentioned in the objective or this prompt is not evidence that the user supplied it.",
+              ...queuedGoal.verifierFeedback ? [`Verifier feedback: ${queuedGoal.verifierFeedback}`] : []
+            ].join("\n"),
+            shouldProceed: true
+          } : { queryToSend: null, shouldProceed: false } : submitType === "retry" /* Retry */ ? { queryToSend: query, shouldProceed: true } : await prepareQueryForGemini(
+            query,
+            userMessageTimestamp,
+            abortSignal,
+            prompt_id,
+            submitType,
+            submittedPrompt,
+            allowConcurrentBtwDuringResponse
+          );
+        } catch (error) {
+          await releaseUndeliveredGoalTurn(metadata?.userAdmission?.turnKey);
+          releaseSubmissionLease();
+          metadata?.onAdmissionFailed?.();
+          throw error;
+        }
+        const { queryToSend, shouldProceed } = preparedQuery;
         if (!shouldProceed || queryToSend === null) {
-          isSubmittingQueryRef.current = false;
+          await releaseUndeliveredGoalTurn(metadata?.userAdmission?.turnKey);
+          releaseSubmissionLease();
           metadata?.onDeliveryFailed?.();
           return;
         }
+        await goalQueueRef?.current?.waitForReservationSettlement?.();
+        if (!queuedGoal && metadata?.claimGoalTurn) {
+          queuedGoal = metadata.claimGoalTurn();
+          if (!queuedGoal) {
+            releaseSubmissionLease();
+            metadata.onGoalClaimDeferred?.();
+            return;
+          }
+        }
+        let userAdmission;
+        if (submitType === "userQuery" /* UserQuery */) {
+          if (metadata?.userAdmission) {
+            const goal2 = metadata.userAdmission.goal ?? goalQueueRef?.current?.claimGoalTurn?.();
+            userAdmission = {
+              turnKey: metadata.userAdmission.turnKey,
+              ...goal2 ? { goal: goal2 } : {}
+            };
+          } else {
+            userAdmission = goalQueueRef?.current?.claimDirectUserAdmission?.() ?? {
+              turnKey: prompt_id
+            };
+          }
+        }
+        const goal = queuedGoal ?? userAdmission?.goal;
+        let goalBinding = metadata?.goalBinding ?? (goal ? bindGoalTurn(
+          goal.permit,
+          goal.turnKey,
+          submitType === "userQuery" /* UserQuery */ ? "user" : "runtime"
+        ) : void 0);
+        const turnKey = goalBinding?.turnKey ?? userAdmission?.turnKey;
+        const turnController = goalBinding?.controller ?? (turnKey ? new AbortController() : void 0);
+        const processingSignal = turnController ? AbortSignal.any([abortSignal, turnController.signal]) : abortSignal;
+        const turnAdmission = turnKey && turnController ? {
+          turnKey,
+          controller: turnController,
+          origin: goalBinding?.origin ?? "user"
+        } : void 0;
+        if (turnAdmission && !goalBinding && submitType === "userQuery" /* UserQuery */ && !allowConcurrentBtwDuringResponse && !activeGoalAdmissionRef.current) {
+          try {
+            if (config.getGoalRuntime().getSnapshot().goal?.status === "active") {
+              activeGoalAdmissionRef.current = turnAdmission;
+            }
+          } catch {
+          }
+        }
         if (submitType === "userQuery" /* UserQuery */ || submitType === "cron" /* Cron */ || submitType === "teammate" /* Teammate */) {
           const formatCheck = checkImageFormatsSupport(queryToSend);
           if (formatCheck.hasUnsupportedFormats) {
@@ -38002,8 +38464,11 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           }
         }
         const finalQueryToSend = queryToSend;
-        lastPromptRef.current = finalQueryToSend;
-        lastPromptErroredRef.current = false;
+        goalTerminalErrorRef.current = false;
+        if (submitType !== "goal" /* Goal */) {
+          lastPromptRef.current = finalQueryToSend;
+          lastPromptErroredRef.current = false;
+        }
         if (submitType === "userQuery" /* UserQuery */ || submitType === "cron" /* Cron */ || submitType === "teammate" /* Teammate */) {
           startNewPrompt();
           if (typeof queryToSend === "string") {
@@ -38032,8 +38497,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           streamingResponseLengthRef.current = 0;
         }
         let cleanupReviewLease = false;
+        let keepGoalBinding = false;
         try {
-          if (dualOutput && submitType !== "toolResult" /* ToolResult */) {
+          if (dualOutput && submitType !== "toolResult" /* ToolResult */ && submitType !== "goal" /* Goal */) {
             const rawParts = typeof finalQueryToSend === "string" ? [finalQueryToSend] : Array.isArray(finalQueryToSend) ? finalQueryToSend : [finalQueryToSend];
             const userParts = rawParts.map(
               (p) => typeof p === "string" ? { text: p } : p
@@ -38053,17 +38519,36 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             finalQueryToSend,
             abortSignal,
             prompt_id,
-            sendOptions
+            {
+              ...sendOptions,
+              ...goalBinding ? {
+                goalPermit: goalBinding.permit,
+                goalTurnKey: goalBinding.turnKey,
+                goalSignal: goalBinding.controller.signal,
+                goalOrigin: goalBinding.origin,
+                getQueuedGoalTurnKey: /* @__PURE__ */ __name(() => goalQueueRef?.current?.peekNextUserBatchKey(true), "getQueuedGoalTurnKey")
+              } : userAdmission ? {
+                goalTurnKey: userAdmission.turnKey,
+                goalSignal: turnController.signal,
+                goalOrigin: "user",
+                getQueuedGoalTurnKey: /* @__PURE__ */ __name(() => goalQueueRef?.current?.peekNextUserBatchKey(true), "getQueuedGoalTurnKey")
+              } : {}
+            }
           );
-          const processingStatus = await processGeminiStreamEvents(
+          const processingResult = await processGeminiStreamEvents(
             stream,
             userMessageTimestamp,
-            abortSignal
+            processingSignal,
+            submitType,
+            turnAdmission
           );
-          if (processingStatus === 1 /* UserCancelled */) {
+          if (!goalBinding && turnAdmission && activeGoalTurnRef.current?.controller === turnAdmission.controller && activeGoalTurnRef.current.turnKey === turnAdmission.turnKey) {
+            goalBinding = activeGoalTurnRef.current;
+          }
+          keepGoalBinding = processingResult.scheduledToolContinuation;
+          if (processingResult.status === 1 /* UserCancelled */) {
             cleanupReviewLease = true;
             submitPromptOnCompleteRef.current = null;
-            isSubmittingQueryRef.current = false;
             metadata?.onDeliveryFailed?.();
             return;
           }
@@ -38090,24 +38575,36 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             );
             immediateDuplicateToolResponses.responses.forEach(
               ({ request, response }, index) => {
-                config.getChatRecordingService?.()?.recordToolResult?.(finalized[index].responseParts, {
-                  callId: request.callId,
-                  status: response.error ? "error" : "success",
-                  resultDisplay: response.resultDisplay,
-                  error: response.error,
-                  errorType: response.errorType
-                });
+                const goalContext = request.goalContext;
+                config.getChatRecordingService?.()?.recordToolResult?.(
+                  finalized[index].responseParts,
+                  {
+                    callId: request.callId,
+                    status: response.error ? "error" : "success",
+                    resultDisplay: response.resultDisplay,
+                    error: response.error,
+                    errorType: response.errorType
+                  },
+                  goalContext ? request.name === ToolNames.GET_GOAL || request.name === ToolNames.UPDATE_GOAL ? {
+                    goalContext: { ...goalContext },
+                    provenance: "goal_runtime"
+                  } : { goalContext: { ...goalContext } } : void 0
+                );
               }
             );
             await submitQuery(
               responseParts,
               "toolResult" /* ToolResult */,
-              immediateDuplicateToolResponses.promptId
+              immediateDuplicateToolResponses.promptId,
+              { goalBinding }
             );
+            if (goalBinding && !turnCancelledRef.current && !abortControllerRef.current?.signal.aborted && goalTurnBindingsRef.current.get(goalBinding.permit.turnId) === goalBinding && !goalBinding.controller.signal.aborted) {
+              keepGoalBinding = true;
+            }
           }
           if (retryCountdownTimerRef.current) {
             clearRetryCountdown();
-          } else if (pendingRetryErrorItemRef.current && !lastPromptErroredRef.current) {
+          } else if (pendingRetryErrorItemRef.current && !lastPromptErroredRef.current && !goalTerminalErrorRef.current) {
             clearRetryCountdown();
           }
           const loopDetected = loopDetectedRef.current;
@@ -38116,7 +38613,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             loopDetectedRef.current = false;
             handleLoopDetectedEvent();
           }
-          if (lastPromptErroredRef.current) {
+          if (lastPromptErroredRef.current || goalTerminalErrorRef.current) {
             metadata?.onDeliveryFailed?.();
           } else {
             metadata?.onDelivered?.();
@@ -38151,8 +38648,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           if (error instanceof UnauthorizedError) {
             onAuthError("Session expired or is unauthorized.");
           } else if (!isNodeError(error) || error.name !== "AbortError") {
-            lastPromptErroredRef.current = true;
-            const retryHint = t("Press Ctrl+Y to retry");
+            if (submitType !== "goal" /* Goal */) {
+              lastPromptErroredRef.current = true;
+            }
+            const retryHint = submitType !== "goal" /* Goal */ ? t("Press Ctrl+Y to retry") : void 0;
             setPendingRetryErrorItem({
               type: "error",
               text: parseAndFormatApiError(
@@ -38178,7 +38677,26 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           if (activeModelStreamsRef.current === 0) {
             setIsResponding(false);
           }
-          isSubmittingQueryRef.current = false;
+          if (goalBinding) {
+            let retainGoalBinding = keepGoalBinding && !goalBinding.controller.signal.aborted;
+            if (retainGoalBinding) {
+              try {
+                const currentPermit = config.getGoalRuntime().permitForTurn(goalBinding.turnKey);
+                retainGoalBinding = currentPermit !== void 0 && sameGoalPermit(currentPermit, goalBinding.permit);
+              } catch {
+              }
+            }
+            if (!retainGoalBinding) {
+              await failClosedGoalTurn(
+                goalBinding,
+                "Goal turn ended without a valid continuation"
+              );
+            }
+          }
+          if (turnAdmission && !goalBinding && activeGoalAdmissionRef.current?.controller === turnAdmission.controller && activeGoalAdmissionRef.current.turnKey === turnAdmission.turnKey) {
+            activeGoalAdmissionRef.current = null;
+          }
+          releaseSubmissionLease();
         }
       });
     },
@@ -38205,7 +38723,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       setPendingThoughtItem,
       dualOutput,
       drainSteerAtBoundary,
-      midTurnDrainRef
+      midTurnDrainRef,
+      goalQueueRef,
+      bindGoalTurn,
+      failClosedGoalTurn,
+      releaseUndeliveredGoalTurn,
+      setSubmissionInFlight
     ]
   );
   const retryLastPrompt = (0, import_react135.useCallback)(async () => {
@@ -38232,6 +38755,11 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     clearRetryCountdown();
     await submitQuery(lastPrompt, "retry" /* Retry */);
   }, [streamingState, addItem, clearRetryCountdown, submitQuery]);
+  const preemptGoalTurn = (0, import_react135.useCallback)((reason) => {
+    const active = activeGoalAdmissionRef.current;
+    if (!active || active.controller.signal.aborted) return;
+    active.controller.abort(reason);
+  }, []);
   const handleApprovalModeChange = (0, import_react135.useCallback)(
     async (newApprovalMode) => {
       if (newApprovalMode === "yolo" /* YOLO */ || newApprovalMode === "auto-edit" /* AUTO_EDIT */) {
@@ -38313,6 +38841,95 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       const geminiTools = completedAndReadyToSubmitTools.filter(
         (t2) => !t2.request.isClientInitiated && !historyCallIdsWithResponse.has(t2.request.callId)
       );
+      let toolGoalPermit;
+      const toolGoalContexts = geminiTools.map(
+        (toolCall) => toolCall.request.goalContext
+      );
+      try {
+        toolGoalPermit = sharedGoalPermit(toolGoalContexts);
+      } catch (error) {
+        const callIds = geminiTools.map((toolCall) => toolCall.request.callId);
+        markToolsAsSubmitted(callIds);
+        const reason = getErrorMessage(error);
+        const bindings = /* @__PURE__ */ new Map();
+        const active = activeGoalTurnRef.current;
+        if (active) {
+          bindings.set(active.turnKey, active);
+        }
+        for (const permit of toolGoalContexts) {
+          if (!permit) continue;
+          const existing = goalTurnBindingsRef.current.get(permit.turnId);
+          const binding = existing ?? {
+            permit: { ...permit },
+            turnKey: `goal-runtime:${permit.turnId}`,
+            controller: new AbortController(),
+            origin: "runtime"
+          };
+          bindings.set(binding.turnKey, binding);
+        }
+        for (const binding of bindings.values()) {
+          await failClosedGoalTurn(binding, reason);
+        }
+        addItem(
+          {
+            type: "error" /* ERROR */,
+            text: reason
+          },
+          Date.now()
+        );
+        return;
+      }
+      if (!toolGoalPermit && toolGoalContexts.length > 0) {
+        const active = activeGoalTurnRef.current;
+        let activeGoalPermitValid = false;
+        if (active) {
+          try {
+            const runtime = config.getGoalRuntime();
+            const currentPermit = runtime.permitForTurn(active.turnKey);
+            activeGoalPermitValid = currentPermit !== void 0 && sameGoalPermit(currentPermit, active.permit);
+          } catch {
+          }
+        }
+        if (active && activeGoalPermitValid) {
+          markToolsAsSubmitted(
+            geminiTools.map((toolCall) => toolCall.request.callId)
+          );
+          const reason = "ToolResult batch is missing the active Goal context";
+          await failClosedGoalTurn(active, reason);
+          addItem(
+            {
+              type: "error" /* ERROR */,
+              text: reason
+            },
+            Date.now()
+          );
+          return;
+        }
+      }
+      let toolGoalBinding;
+      if (toolGoalPermit) {
+        const existing = goalTurnBindingsRef.current.get(toolGoalPermit.turnId);
+        if (existing && !sameGoalPermit(existing.permit, toolGoalPermit)) {
+          markToolsAsSubmitted(
+            geminiTools.map((toolCall) => toolCall.request.callId)
+          );
+          const reason = "ToolResult batch has a stale Goal context";
+          await failClosedGoalTurn(existing, reason);
+          addItem(
+            {
+              type: "error" /* ERROR */,
+              text: reason
+            },
+            Date.now()
+          );
+          return;
+        }
+        toolGoalBinding = existing ?? bindGoalTurn(
+          toolGoalPermit,
+          `goal-runtime:${toolGoalPermit.turnId}`,
+          "runtime"
+        );
+      }
       const didRefreshManagedMemory = await refreshMemoryAfterManagedWrite(
         config,
         completedAndReadyToSubmitTools.map((toolCall) => ({
@@ -38358,6 +38975,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         );
       }
       if (geminiTools.length === 0 && pendingDuplicateResponses.length === 0) {
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation ended without a result"
+          );
+        }
         return;
       }
       const executableQueues = /* @__PURE__ */ new Map();
@@ -38410,18 +39033,32 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         (entry) => entry.responseParts
       );
       orderedResponses.forEach(({ request, response, status }, index) => {
-        config.getChatRecordingService?.()?.recordToolResult?.(finalizedResponses[index].responseParts, {
-          callId: request.callId,
-          status,
-          resultDisplay: response.resultDisplay,
-          error: response.error,
-          errorType: response.errorType
-        });
+        const goalContext = request.goalContext;
+        config.getChatRecordingService?.()?.recordToolResult?.(
+          finalizedResponses[index].responseParts,
+          {
+            callId: request.callId,
+            status,
+            resultDisplay: response.resultDisplay,
+            error: response.error,
+            errorType: response.errorType
+          },
+          goalContext ? request.name === ToolNames.GET_GOAL || request.name === ToolNames.UPDATE_GOAL ? {
+            goalContext: { ...goalContext },
+            provenance: "goal_runtime"
+          } : { goalContext: { ...goalContext } } : void 0
+        );
       });
       if (turnCancelledRef.current || abortControllerRef.current?.signal.aborted) {
         markToolsAsSubmitted(
           geminiTools.map((toolCall) => toolCall.request.callId)
         );
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation was cancelled"
+          );
+        }
         return;
       }
       const allToolsCancelled = geminiTools.every(
@@ -38439,6 +39076,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           (toolCall) => toolCall.request.callId
         );
         markToolsAsSubmitted(callIdsToMarkAsSubmitted2);
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation was cancelled"
+          );
+        }
         return;
       }
       const callIdsToMarkAsSubmitted = geminiTools.map(
@@ -38472,9 +39115,43 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         }
       }
       markToolsAsSubmitted(callIdsToMarkAsSubmitted);
+      const terminatesGoalTurn = geminiTools.some(
+        (toolCall) => toolCall.response.terminateTurn === true
+      );
+      if (terminatesGoalTurn && toolGoalBinding) {
+        geminiClient.addHistory({ role: "user", parts: responsesToSend });
+        try {
+          await config.getChatRecordingService()?.flush();
+          const runtime = await config.getGoalRuntimeReady();
+          const currentPermit = runtime.permitForTurn(toolGoalBinding.turnKey);
+          if (currentPermit && sameGoalPermit(currentPermit, toolGoalBinding.permit)) {
+            await runtime.finishTurn(toolGoalBinding.permit);
+            const snapshot = runtime.getSnapshot();
+            const status = snapshot.goal?.status;
+            if (status === "complete" || status === "blocked" || status === "usage_limited") {
+              addItem(
+                {
+                  type: "goal_state",
+                  snapshot,
+                  cause: status
+                },
+                Date.now()
+              );
+            }
+          }
+        } catch (error) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            `Goal turn could not finish: ${getErrorMessage(error)}`
+          );
+        } finally {
+          releaseGoalTurn(toolGoalBinding);
+        }
+        return;
+      }
       if (config.getEmitToolUseSummaries()) {
         const successfulTools = geminiTools.filter(
-          (tc) => tc.status === "success"
+          (tc) => tc.status === "success" && tc.request.name !== ToolNames.GET_GOAL && tc.request.name !== ToolNames.UPDATE_GOAL
         );
         if (successfulTools.length > 0) {
           const toolInfoForSummary = successfulTools.map((tc) => ({
@@ -38521,6 +39198,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         }
       }
       if (modelSwitchedFromQuotaError) {
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation stopped after a model switch"
+          );
+        }
         return;
       }
       const backgroundTaskRegistry = config.getBackgroundTaskRegistry();
@@ -38530,9 +39213,18 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       });
       if (backgroundLaunchExhaustedCapacity) {
         geminiClient?.addHistory({ role: "user", parts: responsesToSend });
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation stopped: background capacity exhausted"
+          );
+        }
         return;
       }
-      const drained = turnCancelledRef.current || abortControllerRef.current?.signal.aborted ? [] : midTurnDrainRef?.current?.() ?? [];
+      const drained = turnCancelledRef.current || abortControllerRef.current?.signal.aborted ? [] : midTurnDrainRef?.current?.(
+        false,
+        Boolean(activeGoalAdmissionRef.current)
+      ) ?? [];
       let drainedSteer;
       if (drained.length > 0) {
         const midTurnAbort = abortControllerRef.current ?? new AbortController();
@@ -38557,12 +39249,27 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       }
       if (turnCancelledRef.current || abortControllerRef.current?.signal.aborted) {
         drainedSteer?.restore();
+        if (toolGoalBinding) {
+          await failClosedGoalTurn(
+            toolGoalBinding,
+            "Goal tool continuation was cancelled"
+          );
+        }
+        return;
+      }
+      if (toolGoalBinding?.controller.signal.aborted) {
+        drainedSteer?.restore();
+        await failClosedGoalTurn(
+          toolGoalBinding,
+          "Goal tool continuation was preempted"
+        );
         return;
       }
       void submitQuery(responsesToSend, "toolResult" /* ToolResult */, promptId, {
         steerInput: drainedSteer,
         onDelivered: drainedSteer?.accept,
-        onDeliveryFailed: drainedSteer?.restore
+        onDeliveryFailed: drainedSteer?.restore,
+        goalBinding: toolGoalBinding
       });
     },
     [
@@ -38575,7 +39282,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       midTurnDrainRef,
       addItem,
       dualOutput,
-      resolveDrainedSteerMessages
+      resolveDrainedSteerMessages,
+      bindGoalTurn,
+      failClosedGoalTurn,
+      releaseGoalTurn
     ]
   );
   const pendingHistoryItems = (0, import_react135.useMemo)(
@@ -38668,6 +39378,31 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   }, [toolCalls, config, onDebugMessage, history, geminiClient, storage]);
   const notificationQueueRef = (0, import_react135.useRef)([]);
   const [notificationTrigger, setNotificationTrigger] = (0, import_react135.useState)(0);
+  const goalQueuePendingCount = goalQueueRef?.current?.getPendingSubmissionCount?.() ?? 0;
+  const claimSystemGoalTurn = (0, import_react135.useCallback)(() => {
+    if (goalQueueRef?.current?.hasQueuedUserMessages?.()) {
+      return { ready: false };
+    }
+    let goalOwnsTurn = false;
+    try {
+      goalOwnsTurn = goalRequiresExactPermit(
+        config.getGoalRuntime().getSnapshot()
+      );
+    } catch {
+      goalOwnsTurn = false;
+    }
+    if (!goalOwnsTurn) return { ready: true };
+    if ((goalQueueRef?.current?.getPendingSubmissionCount?.() ?? 0) === 0) {
+      return { ready: false };
+    }
+    return {
+      ready: true,
+      claimGoalTurn: /* @__PURE__ */ __name(() => {
+        if (goalQueueRef?.current?.hasQueuedUserMessages?.()) return void 0;
+        return goalQueueRef?.current?.claimGoalTurn?.();
+      }, "claimGoalTurn")
+    };
+  }, [config, goalQueueRef]);
   const getAutonomousLoopTickResolver = (0, import_react135.useCallback)(() => {
     autonomousLoopTickResolverRef.current ??= new AutonomousLoopTickResolver();
     return autonomousLoopTickResolverRef.current;
@@ -38768,6 +39503,21 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       registry.setNotificationCallback(void 0);
     };
   }, [config]);
+  (0, import_react135.useEffect)(() => {
+    const registry = config.getWorkflowRunRegistry();
+    registry.setCompletionCallback((displayText, modelText, meta) => {
+      notificationQueueRef.current.push({
+        displayText,
+        modelText,
+        sendMessageType: "notification" /* Notification */,
+        todoWorkChainId: meta.todoWorkChainId
+      });
+      setNotificationTrigger((n) => n + 1);
+    });
+    return () => {
+      registry.setCompletionCallback(void 0);
+    };
+  }, [config]);
   (0, import_react135.useEffect)(() => {
     const registry = config.getMonitorRegistry();
     registry.setNotificationCallback((displayText, modelText, meta) => {
@@ -38791,6 +39541,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   (0, import_react135.useEffect)(() => {
     if (streamingState === "idle" /* Idle */ && !isSubmittingQueryRef.current && notificationQueueRef.current.length > 0) {
       runOutsideAgentContext(() => {
+        const admission = claimSystemGoalTurn();
+        if (!admission.ready) return;
         const queue = notificationQueueRef.current;
         const monitorRegistry = config.getMonitorRegistry();
         for (let i = queue.length - 1; i >= 0; i--) {
@@ -38805,15 +39557,28 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         const targetType = queue[0].sendMessageType;
         if (targetType === "cron" /* Cron */) {
           const item = queue.shift();
-          addItem(
-            { type: "notification", text: item.displayText },
-            Date.now()
-          );
-          submitQuery(item.modelText, item.sendMessageType, void 0, {
+          if (!item.displayed) {
+            addItem(
+              { type: "notification", text: item.displayText },
+              Date.now()
+            );
+            item.displayed = true;
+          }
+          void submitQuery(item.modelText, item.sendMessageType, void 0, {
             notificationDisplayText: item.displayText,
             todoWorkChainId: item.todoWorkChainId,
             onDelivered: item.onDelivered,
-            onDeliveryFailed: item.onDeliveryFailed
+            onDeliveryFailed: item.onDeliveryFailed,
+            onAdmissionFailed: /* @__PURE__ */ __name(() => {
+              queue.unshift(item);
+            }, "onAdmissionFailed"),
+            claimGoalTurn: admission.claimGoalTurn,
+            onGoalClaimDeferred: /* @__PURE__ */ __name(() => {
+              queue.unshift(item);
+              setNotificationTrigger((n) => n + 1);
+            }, "onGoalClaimDeferred")
+          }).catch((error) => {
+            debugLogger36.warn("Failed to admit cron notification", error);
           });
           return;
         }
@@ -38824,20 +39589,41 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         const batch = queue.splice(0, splitIdx);
         const now = Date.now();
         for (const item of batch) {
-          addItem(
-            { type: "notification", text: item.displayText },
-            now
-          );
+          if (!item.displayed) {
+            addItem(
+              { type: "notification", text: item.displayText },
+              now
+            );
+            item.displayed = true;
+          }
         }
         const combinedModelText = batch.map((e) => e.modelText).join("\n\n");
         const combinedDisplayText = batch.map((e) => e.displayText).join("; ");
-        submitQuery(combinedModelText, targetType, void 0, {
+        void submitQuery(combinedModelText, targetType, void 0, {
           notificationDisplayText: combinedDisplayText,
-          todoWorkChainId: batch[0]?.todoWorkChainId
+          todoWorkChainId: batch[0]?.todoWorkChainId,
+          onAdmissionFailed: /* @__PURE__ */ __name(() => {
+            queue.unshift(...batch);
+          }, "onAdmissionFailed"),
+          claimGoalTurn: admission.claimGoalTurn,
+          onGoalClaimDeferred: /* @__PURE__ */ __name(() => {
+            queue.unshift(...batch);
+            setNotificationTrigger((n) => n + 1);
+          }, "onGoalClaimDeferred")
+        }).catch((error) => {
+          debugLogger36.warn("Failed to admit background notification", error);
         });
       });
     }
-  }, [streamingState, submitQuery, notificationTrigger, addItem, config]);
+  }, [
+    streamingState,
+    submitQuery,
+    notificationTrigger,
+    addItem,
+    config,
+    claimSystemGoalTurn,
+    goalQueuePendingCount
+  ]);
   const teammateQueueRef = (0, import_react135.useRef)([]);
   const [teammateTrigger, setTeammateTrigger] = (0, import_react135.useState)(0);
   (0, import_react135.useEffect)(() => {
@@ -38873,21 +39659,43 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   (0, import_react135.useEffect)(() => {
     if (streamingState === "idle" /* Idle */ && !isSubmittingQueryRef.current && teammateQueueRef.current.length > 0) {
       runOutsideAgentContext(() => {
+        const admission = claimSystemGoalTurn();
+        if (!admission.ready) return;
         const batch = teammateQueueRef.current.splice(0);
         for (const entry of batch) {
-          addItem(
-            { type: "notification", text: entry.display },
-            Date.now()
-          );
+          if (!entry.displayed) {
+            addItem(
+              { type: "notification", text: entry.display },
+              Date.now()
+            );
+            entry.displayed = true;
+          }
         }
         const modelText = batch.map((e) => e.modelText).join("\n\n");
         const display = batch.map((e) => e.display).join("; ");
-        submitQuery(modelText, "teammate" /* Teammate */, void 0, {
-          notificationDisplayText: display
+        void submitQuery(modelText, "teammate" /* Teammate */, void 0, {
+          notificationDisplayText: display,
+          onAdmissionFailed: /* @__PURE__ */ __name(() => {
+            teammateQueueRef.current.unshift(...batch);
+          }, "onAdmissionFailed"),
+          claimGoalTurn: admission.claimGoalTurn,
+          onGoalClaimDeferred: /* @__PURE__ */ __name(() => {
+            teammateQueueRef.current.unshift(...batch);
+            setTeammateTrigger((n) => n + 1);
+          }, "onGoalClaimDeferred")
+        }).catch((error) => {
+          debugLogger36.warn("Failed to admit teammate notification", error);
         });
       });
     }
-  }, [streamingState, submitQuery, teammateTrigger, addItem]);
+  }, [
+    streamingState,
+    submitQuery,
+    teammateTrigger,
+    addItem,
+    claimSystemGoalTurn,
+    goalQueuePendingCount
+  ]);
   return {
     streamingState,
     submitQuery,
@@ -38895,6 +39703,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
     pendingHistoryItems,
     thought,
     cancelOngoingRequest,
+    preemptGoalTurn,
     retryLastPrompt,
     pendingToolCalls: toolCalls,
     handleApprovalModeChange,
@@ -42196,6 +43005,131 @@ function shouldDrainMessageQueue({
   return isConfigInitialized && streamingState === "idle" /* Idle */ && !isProcessing && !dialogsVisible && messageQueueLength > 0;
 }
 __name(shouldDrainMessageQueue, "shouldDrainMessageQueue");
+function useQueuedSubmissionDrain({
+  config,
+  isConfigInitialized,
+  streamingState,
+  isProcessing,
+  dialogsVisible,
+  pendingSubmissionCount,
+  getPendingSubmissionCount,
+  popNextSubmission,
+  enqueueGoalTurn,
+  restoreMessages,
+  submitQuery,
+  submissionInFlightRef,
+  submissionSettledRevision
+}) {
+  const goalRuntimeSessionId = config.getSessionId();
+  const [goalQueueRevision, setGoalQueueRevision] = (0, import_react161.useState)(0);
+  (0, import_react161.useEffect)(() => {
+    try {
+      return config.getGoalRuntime().subscribe(() => {
+        setGoalQueueRevision((revision) => revision + 1);
+      });
+    } catch {
+      return void 0;
+    }
+  }, [config, goalRuntimeSessionId]);
+  const queueDrainingRef = (0, import_react161.useRef)(false);
+  const admissionFailureRef = (0, import_react161.useRef)(null);
+  const [queueDrainNonce, setQueueDrainNonce] = (0, import_react161.useState)(0);
+  (0, import_react161.useEffect)(() => {
+    if (queueDrainingRef.current || submissionInFlightRef.current) return;
+    const admissionFailure = admissionFailureRef.current;
+    if (admissionFailure) {
+      if (pendingSubmissionCount === 0) {
+        admissionFailureRef.current = null;
+      } else if (pendingSubmissionCount <= admissionFailure.pendingSubmissionCount && goalQueueRevision === admissionFailure.goalQueueRevision && streamingState === admissionFailure.streamingState && isProcessing === admissionFailure.isProcessing) {
+        return;
+      } else {
+        admissionFailureRef.current = null;
+      }
+    }
+    if (!shouldDrainMessageQueue({
+      isConfigInitialized,
+      streamingState,
+      isProcessing,
+      dialogsVisible,
+      messageQueueLength: pendingSubmissionCount
+    })) {
+      return;
+    }
+    let goalControlMode = "normal";
+    try {
+      const status = config.getGoalRuntime().getSnapshot().goal?.status;
+      if (status === "active") {
+        goalControlMode = "priority";
+      }
+    } catch {
+    }
+    const submission = popNextSubmission(goalControlMode);
+    if (submission === null) return;
+    queueDrainingRef.current = true;
+    let admissionFailed = false;
+    const markAdmissionFailed = /* @__PURE__ */ __name(() => {
+      admissionFailed = true;
+      admissionFailureRef.current = {
+        pendingSubmissionCount: getPendingSubmissionCount(),
+        goalQueueRevision,
+        streamingState,
+        isProcessing
+      };
+    }, "markAdmissionFailed");
+    const request = submission.kind === "goal" ? submitQuery(
+      submission.continuationContext,
+      "goal" /* Goal */,
+      void 0,
+      {
+        goal: submission,
+        onAdmissionFailed: /* @__PURE__ */ __name(() => {
+          enqueueGoalTurn(submission);
+          markAdmissionFailed();
+        }, "onAdmissionFailed")
+      }
+    ) : submitQuery(
+      submission.modelText,
+      "userQuery" /* UserQuery */,
+      void 0,
+      {
+        userAdmission: { turnKey: submission.turnKey },
+        ...submission.submittedPrompt === void 0 ? {} : { submittedPrompt: submission.submittedPrompt },
+        onAdmissionFailed: /* @__PURE__ */ __name(() => {
+          restoreMessages(
+            [submission.modelText],
+            submission.submittedPrompt
+          );
+          markAdmissionFailed();
+        }, "onAdmissionFailed")
+      }
+    );
+    void Promise.resolve(request).catch((error) => {
+      debugLogger39.warn("Queued submission failed during admission", error);
+    }).finally(() => {
+      queueDrainingRef.current = false;
+      if (!admissionFailed) {
+        setQueueDrainNonce((nonce) => nonce + 1);
+      }
+    });
+  }, [
+    config,
+    dialogsVisible,
+    enqueueGoalTurn,
+    goalQueueRevision,
+    getPendingSubmissionCount,
+    isConfigInitialized,
+    isProcessing,
+    pendingSubmissionCount,
+    popNextSubmission,
+    queueDrainNonce,
+    restoreMessages,
+    streamingState,
+    submissionInFlightRef,
+    submissionSettledRevision,
+    submitQuery
+  ]);
+}
+__name(useQueuedSubmissionDrain, "useQueuedSubmissionDrain");
 function getSpeculativeToolResult(response) {
   const responseRecord = typeof response === "object" && response ? response : void 0;
   const hasError = responseRecord !== void 0 && Object.prototype.hasOwnProperty.call(responseRecord, "error");
@@ -42415,6 +43349,7 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
     (async () => {
       profileCheckpoint("config_initialize_start");
       await config.initialize();
+      await waitForGoalRuntime(config);
       setStartupWarnings(
         (currentWarnings) => mergeStartupWarnings(currentWarnings, config.getWarnings())
       );
@@ -42446,10 +43381,6 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
         if (userTurnCount > 0) {
           seedPromptCount(userTurnCount);
         }
-        try {
-          restoreGoalFromHistory(historyItems, config, historyManager.addItem);
-        } catch {
-        }
         const recovered = await config.loadPausedBackgroundAgents(
           config.getSessionId()
         );
@@ -42754,6 +43685,7 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
     isFastModelMode,
     isVoiceModelMode,
     isVisionModelMode,
+    isCompactionModelMode,
     isImageModelMode,
     modelDialogPersistScope,
     openModelDialog,
@@ -43185,8 +44117,21 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
   }, [config, historyManager, settings.merged]);
   const cancelHandlerRef = (0, import_react161.useRef)(() => {
   });
-  const midTurnDrainRef = (0, import_react161.useRef)(null);
+  const midTurnDrainRef = (0, import_react161.useRef)(
+    null
+  );
   const midTurnRestoreRef = (0, import_react161.useRef)(null);
+  const goalQueueRef = (0, import_react161.useRef)(null);
+  const goalReservationSettlementRef = (0, import_react161.useRef)(Promise.resolve());
+  const submissionInFlightRef = (0, import_react161.useRef)(false);
+  const [submissionSettledRevision, setSubmissionSettledRevision] = (0, import_react161.useState)(0);
+  const onSubmissionSettled = (0, import_react161.useCallback)(() => {
+    setSubmissionSettledRevision((revision) => revision + 1);
+  }, []);
+  const waitForReservationSettlement = (0, import_react161.useCallback)(
+    () => goalReservationSettlementRef.current,
+    []
+  );
   const {
     streamingState,
     submitQuery,
@@ -43194,6 +44139,7 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
     pendingHistoryItems: pendingGeminiHistoryItems,
     thought,
     cancelOngoingRequest,
+    preemptGoalTurn,
     retryLastPrompt,
     handleApprovalModeChange,
     activePtyId,
@@ -43225,7 +44171,8 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
     logger,
     availableTerminalHeightRef,
     terminalWidthRef,
-    midTurnRestoreRef
+    midTurnRestoreRef,
+    goalQueueRef
   );
   cancelOngoingRequestRef.current = cancelOngoingRequest;
   isIdleRef.current = streamingState === "idle" /* Idle */;
@@ -43292,35 +44239,85 @@ var AppContainer = /* @__PURE__ */ __name((props) => {
   });
   const {
     messageQueue,
+    pendingSubmissionCount,
     addMessage,
+    enqueueGoalTurn,
+    peekNextUserBatchKey,
+    hasQueuedUserMessages,
+    getPendingSubmissionCount,
+    claimGoalTurn,
+    claimDirectUserAdmission,
+    removeGoalTurns,
+    popNextSubmission,
     popAllMessages,
     restoreMessages,
-    drainQueue,
-    popNextTurn
+    drainQueue
   } = useMessageQueue();
-  const submitUserQuery = (0, import_react161.useCallback)(
-    (submission) => submitQuery(
-      submission.modelText,
-      "userQuery" /* UserQuery */,
-      void 0,
-      submission.submittedPrompt === void 0 ? void 0 : { submittedPrompt: submission.submittedPrompt }
-    ),
-    [submitQuery]
+  midTurnDrainRef.current = drainQueue;
+  midTurnRestoreRef.current = restoreMessages;
+  goalQueueRef.current = {
+    peekNextUserBatchKey,
+    claimDirectUserAdmission,
+    claimGoalTurn,
+    hasQueuedUserMessages,
+    getPendingSubmissionCount,
+    waitForReservationSettlement,
+    submissionInFlightRef,
+    onSubmissionSettled
+  };
+  const releaseQueuedGoalReservations = (0, import_react161.useCallback)(
+    (turnKeys) => {
+      let runtime;
+      try {
+        runtime = config.getGoalRuntime();
+      } catch {
+        return;
+      }
+      const previousSettlement = goalReservationSettlementRef.current;
+      const settlement = previousSettlement.then(async () => {
+        await Promise.all(
+          turnKeys.map((turnKey) => runtime.releaseTurn(turnKey))
+        );
+      });
+      goalReservationSettlementRef.current = settlement.catch((error) => {
+        debugLogger39.warn(
+          `Failed to release queued Goal turns: ${getErrorMessage(error)}`
+        );
+      });
+    },
+    [config]
   );
   const popAllQueuedMessages = (0, import_react161.useCallback)(() => {
+    const goalTurnKeys = removeGoalTurns();
+    if (goalTurnKeys.length > 0) {
+      releaseQueuedGoalReservations(goalTurnKeys);
+    }
     const submission = popAllMessages();
     if (submission === null) return null;
     restoredSubmissionRef.current = submission;
     submittedPromptProvenanceUnavailableRef.current = false;
     return submission.modelText;
-  }, [popAllMessages]);
-  midTurnDrainRef.current = drainQueue;
-  midTurnRestoreRef.current = restoreMessages;
+  }, [popAllMessages, releaseQueuedGoalReservations, removeGoalTurns]);
+  (0, import_react161.useEffect)(() => {
+    const host = {
+      startGoalTurn: /* @__PURE__ */ __name(async (input) => {
+        enqueueGoalTurn(input);
+      }, "startGoalTurn"),
+      preemptGoalTurn: /* @__PURE__ */ __name((reason) => {
+        removeGoalTurns();
+        preemptGoalTurn(reason);
+      }, "preemptGoalTurn")
+    };
+    return config.bindGoalTurnHost(host);
+  }, [config, enqueueGoalTurn, preemptGoalTurn, removeGoalTurns]);
   const remoteInput = useRemoteInput();
   (0, import_react161.useEffect)(() => {
     if (!remoteInput) return;
-    remoteInput.setSubmitFn((text) => submitQuery(text));
-  }, [remoteInput, submitQuery]);
+    remoteInput.setSubmitFn((text) => {
+      addMessage(text);
+      return true;
+    });
+  }, [addMessage, remoteInput]);
   (0, import_react161.useEffect)(() => {
     if (!remoteInput) return;
     if (streamingState === "idle" /* Idle */) {
@@ -43473,9 +44470,15 @@ ${buildWorkflowSteeringNotice()}
         return;
       }
       if (streamingState === "responding" /* Responding */ && isBtwCommand(submittedValue)) {
-        void submitUserQuery({
-          modelText: submittedValue,
-          submittedPrompt
+        void Promise.resolve(
+          submitQuery(
+            submittedValue,
+            "userQuery" /* UserQuery */,
+            void 0,
+            submittedPrompt === void 0 ? void 0 : { submittedPrompt }
+          )
+        ).catch((error) => {
+          debugLogger39.warn("Failed to admit /btw submission", error);
         });
         return;
       }
@@ -43561,9 +44564,15 @@ ${buildWorkflowSteeringNotice()}
         speculationRef.current = IDLE_SPECULATION;
       }
       if (streamingState === "idle" /* Idle */ && !isProcessing && isSlashCommand(submittedValue)) {
-        void submitUserQuery({
-          modelText: submittedValue,
-          submittedPrompt
+        void Promise.resolve(
+          submitQuery(
+            submittedValue,
+            "userQuery" /* UserQuery */,
+            void 0,
+            submittedPrompt === void 0 ? void 0 : { submittedPrompt }
+          )
+        ).catch((error) => {
+          debugLogger39.warn("Failed to admit slash command", error);
         });
         return;
       }
@@ -43574,7 +44583,7 @@ ${buildWorkflowSteeringNotice()}
       agentViewState,
       streamingState,
       isProcessing,
-      submitUserQuery,
+      submitQuery,
       handleSlashCommand,
       slashCommands,
       config,
@@ -43622,6 +44631,10 @@ ${buildWorkflowSteeringNotice()}
         pendingHistoryItems2.push(info.pendingItem);
       }
       const draftWasEmpty = buffer.text.length === 0;
+      const goalTurnKeys = removeGoalTurns();
+      if (goalTurnKeys.length > 0) {
+        releaseQueuedGoalReservations(goalTurnKeys);
+      }
       const popped = popAllMessages();
       if (popped) {
         restoredSubmissionRef.current = popped;
@@ -43632,6 +44645,9 @@ ${buildWorkflowSteeringNotice()}
 ${currentText}` : popped.modelText
         );
       }
+      if (info?.wasGoalTurn) {
+        geminiClient?.stripOrphanedUserEntriesFromHistory?.();
+      }
       if (!draftWasEmpty) {
         debugLogger39.debug("auto-restore bail: buffer was non-empty");
         return;
@@ -43718,6 +44734,8 @@ ${currentText}` : popped.modelText
     [
       buffer,
       popAllMessages,
+      releaseQueuedGoalReservations,
+      removeGoalTurns,
       historyManager,
       logger,
       geminiClient,
@@ -44621,36 +45639,21 @@ ${migrationResult.failedFiles.map((f) => `  \u2022 ${f.file}: ${f.error}`).join(
     settings.merged.ui?.showStatusInTitle,
     config
   ]);
-  const queueDrainingRef = (0, import_react161.useRef)(false);
-  const [queueDrainNonce, setQueueDrainNonce] = (0, import_react161.useState)(0);
-  (0, import_react161.useEffect)(() => {
-    if (queueDrainingRef.current) return;
-    if (!shouldDrainMessageQueue({
-      isConfigInitialized,
-      streamingState,
-      isProcessing,
-      dialogsVisible,
-      messageQueueLength: messageQueue.length
-    })) {
-      return;
-    }
-    const submission = popNextTurn();
-    if (submission === null) return;
-    queueDrainingRef.current = true;
-    Promise.resolve(submitUserQuery(submission)).finally(() => {
-      queueDrainingRef.current = false;
-      setQueueDrainNonce((n) => n + 1);
-    });
-  }, [
+  useQueuedSubmissionDrain({
+    config,
     isConfigInitialized,
     streamingState,
     isProcessing,
     dialogsVisible,
-    messageQueue,
-    popNextTurn,
-    submitUserQuery,
-    queueDrainNonce
-  ]);
+    pendingSubmissionCount,
+    getPendingSubmissionCount,
+    popNextSubmission,
+    enqueueGoalTurn,
+    restoreMessages,
+    submitQuery,
+    submissionInFlightRef,
+    submissionSettledRevision
+  });
   const nightly = props.version.includes("nightly");
   const uiState = (0, import_react161.useMemo)(
     () => ({
@@ -44675,6 +45678,7 @@ ${migrationResult.failedFiles.map((f) => `  \u2022 ${f.file}: ${f.error}`).join(
       isFastModelMode,
       isVoiceModelMode,
       isVisionModelMode,
+      isCompactionModelMode,
       isImageModelMode,
       modelDialogPersistScope,
       isTrustDialogOpen,
@@ -44819,6 +45823,7 @@ ${migrationResult.failedFiles.map((f) => `  \u2022 ${f.file}: ${f.error}`).join(
       isFastModelMode,
       isVoiceModelMode,
       isVisionModelMode,
+      isCompactionModelMode,
       isImageModelMode,
       modelDialogPersistScope,
       isTrustDialogOpen,