@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/{orchestrator-WZYB54DM.js → orchestrator-ZKBPCHW6.js}

@@ -1,4 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ShareDomainModule
+} from "./chunk-TD7UE2L5.js";
+import {
+  bootstrapInputFromInitOptions,
+  modelBootstrapGenerate,
+  resolveBootstrapRoute
+} from "./chunk-3DUR4WUA.js";
+import "./chunk-J5Q24KAG.js";
 import {
   DEFAULT_KEEP_RECENT_TOKENS,
   DEFAULT_RESERVE_TOKENS,
@@ -12,7 +21,7 @@ import {
   projectWorkingSet,
   resolveWorkingSetPolicy,
   selectVisibleEntries
-} from "./chunk-WHJYKASB.js";
+} from "./chunk-3MRC2YSQ.js";
 import {
   assistantSessionPayload,
   backendCacheVerdict,
@@ -45,86 +54,199 @@ import {
   toolNamesFromAgentState,
   toolResultSummary,
   toolSignatureFromState
-} from "./chunk-WJHBC77E.js";
-import {
-  ShareDomainModule
-} from "./chunk-FOT2FX5J.js";
-import {
-  bootstrapInputFromInitOptions,
-  modelBootstrapGenerate,
-  resolveBootstrapRoute
-} from "./chunk-EOOQZZDE.js";
-import "./chunk-J5Q24KAG.js";
+} from "./chunk-N5XKWMDW.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule,
   renderAgentCatalogSectionsFromSpecs
-} from "./chunk-EBEFWSGL.js";
+} from "./chunk-3UUY7R3Z.js";
+import {
+  flushRawStdout,
+  writeRawStdout
+} from "./chunk-2VTFPG5O.js";
 import {
   SafetyDomainModule
-} from "./chunk-J7PIKKWC.js";
+} from "./chunk-WXCJ7VME.js";
 import {
   LifecycleDomainModule,
   describeUpgradeNotice
-} from "./chunk-JTSEDYVQ.js";
+} from "./chunk-DG4M6ZUE.js";
 import {
   ensureClioState,
   takeUpgradeNotice
-} from "./chunk-3HAPLH5M.js";
+} from "./chunk-T3Z6VAAF.js";
 import {
   ConfigDomainModule,
   createConfigDomainModule,
   loadDomains
-} from "./chunk-BMWK7ZIZ.js";
+} from "./chunk-465CC7FK.js";
+import {
+  discoverDeclaredChecks
+} from "./chunk-P3JGPQFL.js";
+import {
+  buildRecallFields,
+  recallErrorMessage,
+  recallParentTurnId,
+  recallableRefListing,
+  resolveRecall
+} from "./chunk-MV2VUEJC.js";
+import {
+  foldWorkingSet
+} from "./chunk-TZSKNMZG.js";
+import {
+  classifyLibraryRequirements,
+  createResourcesDomainModule,
+  discoverLibrary,
+  installLibraryPlan,
+  libraryEntryInstalled,
+  libraryEntryPin,
+  libraryEntryRef,
+  libraryInstallPath,
+  planLibraryInstall
+} from "./chunk-PZ4I4JE2.js";
+import {
+  AgentsDomainModule
+} from "./chunk-YSEHGPCT.js";
+import "./chunk-HCBCAYZU.js";
+import "./chunk-DR52UMZW.js";
+import {
+  MARKETPLACE_UNCONFIGURED,
+  discoverMarketplaceSkills,
+  getMarketplaceSkills,
+  installSkill,
+  modelVisibleSkills,
+  parseSkillCommand
+} from "./chunk-AD7Y7STJ.js";
+import "./chunk-AMKHQW3C.js";
 import {
   compileScoutTransition,
   createDispatchRunEventRegistry
-} from "./chunk-AB4XIIVB.js";
+} from "./chunk-YKOFT37S.js";
 import {
   monitorToolSurface
-} from "./chunk-FJ3H4MN5.js";
+} from "./chunk-IHKBWSXF.js";
 import {
   COST_NOT_MEASURED,
   ObservabilityDomainModule,
   aggregateCostAmounts,
   costAggregateForAmount,
   formatCostAggregate,
-  readAccountabilitySummary
-} from "./chunk-5UJ6ECTS.js";
+  readAccountabilitySummary,
+  recordBackgroundMemoryStep
+} from "./chunk-5PVQ4SRS.js";
 import {
   appendOutOfTurnUsageRow
-} from "./chunk-GWS3VEIW.js";
-import "./chunk-HFSBBKSQ.js";
-import "./chunk-VREKEFLL.js";
+} from "./chunk-FWDFM5ZU.js";
+import "./chunk-YW7UVM5V.js";
+import "./chunk-D73KXYPF.js";
 import {
   steerToolSurface
-} from "./chunk-WEH5XRJQ.js";
+} from "./chunk-WIE7ZOSW.js";
+import "./chunk-FALJGAWU.js";
 import {
-  flushRawStdout,
-  writeRawStdout
-} from "./chunk-2VTFPG5O.js";
-import "./chunk-YD734TPH.js";
+  ClioEditor,
+  CombinedAutocompleteProvider,
+  Container,
+  DEFAULT_SELECT_THEME,
+  FILTER_HINT,
+  FocusBox,
+  GLYPH,
+  Input,
+  MUTATION_PREVIEW_KEY,
+  Markdown,
+  Marked,
+  SGR_DIM,
+  SGR_RESET,
+  ScrollView,
+  SelectList,
+  Text,
+  VStack,
+  abbreviateModelId,
+  barSep,
+  brandMark,
+  buildHint,
+  buildResponsiveHint,
+  clioError,
+  clioTheme,
+  collapseHomePath,
+  createAgentProgress,
+  createKeybindingManager,
+  createProcessInteractiveShell,
+  detectPlatformKeybindingWarnings,
+  detectTerminalKeySupport,
+  dotSep,
+  fgSequence,
+  fitHintEntries,
+  fitUnits,
+  formatCompactMs,
+  formatContextPercent,
+  formatInvalidKeybindingNotice,
+  formatPlatformKeybindingNotice,
+  formatRuntimeResolutionDiagnostic,
+  formatTargetLabel,
+  frame,
+  fuzzyFilter,
+  getActiveRenderTrace,
+  getKeybindings,
+  innerDivider,
+  isClioToken,
+  isKeyRelease,
+  joinChips,
+  joinSections,
+  listGroupHeader,
+  markdownTheme,
+  matchesKey,
+  padAnsi,
+  paintHex,
+  permissionHintEntries,
+  rule,
+  runtimeResolutionDiagnosticLine,
+  screenTitle,
+  sectionTag,
+  selectListTheme,
+  showClioOverlayFrame,
+  spinnerFrame,
+  stripTerminalSequences,
+  truncateToWidth,
+  validateKeybindings,
+  visibleWidth,
+  wrapTextWithAnsi,
+  writeInputWedgeDump
+} from "./chunk-NNNWO6F2.js";
+import {
+  getTerminationCoordinator
+} from "./chunk-BVDVID7E.js";
 import {
   createContextDomainModule,
   loadProjectClioMd
-} from "./chunk-4DWFMQDR.js";
+} from "./chunk-HJB5IUKP.js";
 import "./chunk-LCGCVYZ4.js";
 import {
   renderCodewikiDigest
-} from "./chunk-5WIGXA4T.js";
+} from "./chunk-47CMYGET.js";
 import {
   buildMemoryPromptSection,
   canonicalMemoryRepositoryIdentity,
   createTaskMemoryTrace,
   describeTaskMemoryActivity,
+  formatTaskMemorySpend,
   loadMemoryRecordsSync,
+  proposeInjectedTaskMemory,
   proposeMemoryPromotion,
+  readTaskMemorySpendSummary,
   renderTaskMemoryHandoffSource,
   seedTaskMemoryFromNewestHandoff,
   taskMemoryBankSize,
   taskMemoryHandoffSeedOffer,
   taskMemoryTracePath
-} from "./chunk-6M7VS3J3.js";
+} from "./chunk-5T7RBWN2.js";
+import {
+  listWikiPages,
+  wikiCompleteness,
+  wikiStaleness,
+  wikiStalenessAsync
+} from "./chunk-NDINPTJ4.js";
+import "./chunk-MXHC5QYU.js";
 import {
   ACP_MAX_CHUNK_BYTES,
   ACP_MAX_RAW_RECORD_BYTES,
@@ -137,6 +259,7 @@ import {
   AcpTimeoutError,
   WORKER_OUTPUT_MAX_BYTES,
   acpErrorMessage,
+  capacityLeaseUsage,
   createDispatchDomainModule,
   createRunReceiptQuality,
   createStdioServerTransport,
@@ -148,8 +271,18 @@ import {
   openLedger,
   protectedResidencyModels,
   readGateDecisionArtifacts,
-  readPendingGateDecisions
-} from "./chunk-UUANF5CR.js";
+  readPendingGateDecisions,
+  renderDispatchReviewerTask
+} from "./chunk-TEO2TLVN.js";
+import {
+  formatTrustSummaryLine,
+  inspectRunReceiptTrustStatus,
+  isReceiptIntegrity,
+  retiredReceiptIntegrity,
+  retiredReceiptIntegrityReason,
+  summarizeTrustStatus,
+  verifyReceiptIntegrity
+} from "./chunk-MLOK6ZOS.js";
 import {
   SessionDomainModule,
   addResponseModelIdObservationCount,
@@ -163,81 +296,28 @@ import {
   readAuditRows,
   responseModelIdObservationCountsLabel,
   responseModelIdObservationFromRecord
-} from "./chunk-6TUKSZVF.js";
+} from "./chunk-LXPJXFM5.js";
 import {
+  describeWriteBoundaryAttributionDowngrade,
   gitCheckoutRoot,
   isGitRepository,
   preflightWriteBoundaries,
   recoverCleanupReadyCompeteGroups
-} from "./chunk-KZ2H5X4G.js";
+} from "./chunk-ECUO3KDP.js";
 import {
+  bindExecutionPlanEndpoints,
   compileFleetExecutionPlan,
   requireAgentSteps
-} from "./chunk-M4AKACEO.js";
+} from "./chunk-HKO36JWF.js";
 import {
   parseRigorOverride,
   resolveRigor
 } from "./chunk-RVG5JXAL.js";
 import {
-  isReceiptIntegrity,
-  verifyReceiptIntegrity
-} from "./chunk-ZGH7FGS5.js";
-import "./chunk-TSHXZTOQ.js";
-import {
-  shellQuote
-} from "./chunk-TXOTCRLG.js";
-import {
-  emptyWorkspaceSnapshot,
-  probeGitStatusAsync,
-  probeWorkspaceAsync
-} from "./chunk-HVDIIIQW.js";
-import {
-  discoverDeclaredChecks
-} from "./chunk-PD3MESLB.js";
-import {
-  listWikiPages,
-  wikiCompleteness,
-  wikiStaleness,
-  wikiStalenessAsync
-} from "./chunk-NDINPTJ4.js";
-import "./chunk-MVVUPGPW.js";
-import {
-  buildRecallFields,
-  recallErrorMessage,
-  recallParentTurnId,
-  recallableRefListing,
-  resolveRecall
-} from "./chunk-ZZMN5OM4.js";
-import {
-  foldWorkingSet
-} from "./chunk-TZSKNMZG.js";
-import {
-  classifyLibraryRequirements,
-  createResourcesDomainModule,
-  discoverLibrary,
-  installLibraryPlan,
-  libraryEntryInstalled,
-  libraryEntryPin,
-  libraryEntryRef,
-  libraryInstallPath,
-  planLibraryInstall
-} from "./chunk-THKY7CD7.js";
-import {
-  AgentsDomainModule
-} from "./chunk-UVDSQ6LW.js";
-import "./chunk-DR52UMZW.js";
-import {
-  MARKETPLACE_UNCONFIGURED,
-  discoverMarketplaceSkills,
-  getMarketplaceSkills,
-  installSkill,
-  modelVisibleSkills,
-  parseSkillCommand
-} from "./chunk-C4JBQ5SR.js";
-import "./chunk-2SFS6XQE.js";
-import {
-  ExtensionsDomainModule
-} from "./chunk-ZWLZP4ZT.js";
+  foldPromptCacheTelemetry,
+  hasPromptCacheTelemetry,
+  uncachedPrefillTokens
+} from "./chunk-3DPEIQKN.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-W6GROXXM.js";
@@ -250,7 +330,21 @@ import {
   renderFleetPrompt,
   validateFleetCommands,
   validateFleetGraph
-} from "./chunk-KCMKRQX4.js";
+} from "./chunk-HPCTNZM2.js";
+import "./chunk-RKKLTLYB.js";
+import {
+  ExtensionsDomainModule
+} from "./chunk-5QKCQQ3E.js";
+import "./chunk-JVCV3ICN.js";
+import "./chunk-5HFBWUMU.js";
+import {
+  shellQuote
+} from "./chunk-TXOTCRLG.js";
+import {
+  emptyWorkspaceSnapshot,
+  probeGitStatusAsync,
+  probeWorkspaceAsync
+} from "./chunk-HVDIIIQW.js";
 import {
   formatBootTrace,
   traceBoot
@@ -258,6 +352,7 @@ import {
 import {
   ASK_USER_OTHER_LABEL,
   INTERACTIVE_LOOP_BLOCK_BUDGET,
+  applyEditsToNormalizedContent,
   askAxis,
   askUserExposure,
   assertRegisteredBuiltinTools,
@@ -272,16 +367,20 @@ import {
   decisionFactsForPermission,
   diffWords,
   finalizeAskUserInterviewForHost,
+  generateDiffString,
   lazyTool,
+  normalizeToLF,
   patchProviderThinkingPayload,
+  patchResponseSchemaPayloadForDialect,
   patchToolChoiceNamedPayload,
   patchToolChoiceNonePayload,
   readOrchTurnToolCallBudget,
   registerCoreTools,
   resolveFdBinary,
   resolveSessionTools,
-  sanitizeLockedSynthesisMessage
-} from "./chunk-QCTRSGHQ.js";
+  sanitizeLockedSynthesisMessage,
+  stripBom
+} from "./chunk-R7LNVMCS.js";
 import {
   HEADLESS_PERMISSION_DENIED_REASON
 } from "./chunk-K7VKOLQQ.js";
@@ -289,6 +388,7 @@ import {
   MIDDLEWARE_HOOK_TEXT_MAX_CHARS,
   MiddlewareDomainModule,
   WATCHDOG_TASK,
+  announceMemoryStepEndpoint,
   createDetachedDispatchNudgeRegistration,
   createHookReceiptLog,
   createMemoryInterventionRegistration,
@@ -303,9 +403,12 @@ import {
   openDetachedBatchViews,
   watchdogBriefing,
   writeMiddlewareDiagnosticToStderr
-} from "./chunk-XEGB6BCN.js";
-import "./chunk-IR4CFBFN.js";
+} from "./chunk-GAYUJ7LE.js";
+import "./chunk-HAY4ZE2P.js";
 import "./chunk-UOV2BYIW.js";
+import "./chunk-CA42X6KT.js";
+import "./chunk-OEDBCISO.js";
+import "./chunk-5DQRIYDZ.js";
 import {
   DISPATCH_PLAN_PREPARATION_ERROR_ARGUMENT,
   RESOLVED_DISPATCH_PLAN_ARGUMENT,
@@ -317,11 +420,14 @@ import {
   stringArg,
   timeoutMsArg,
   withResolvedDispatchPlan
-} from "./chunk-EELBMBT6.js";
+} from "./chunk-VKBMFOYV.js";
 import {
   TaskMemoryBank,
   createTaskMemoryTelemetrySink
-} from "./chunk-WHGPSPT5.js";
+} from "./chunk-O6I4CIEU.js";
+import {
+  escapeRegExp
+} from "./chunk-VG7TBQIY.js";
 import {
   COUNCIL_JUDGE_PROMPT,
   DISPATCH_BRIEFING_MAX_BYTES,
@@ -338,66 +444,61 @@ import {
   formatBudgetReasons,
   formatBudgetRequest,
   formatEffectiveBudget,
+  isResponseSchemaRejection,
   isToolProfileName,
   normalizeDispatchIntent,
   redactSecretString,
   redactToolArgs,
+  renderCouncilVoteMemberTask,
+  responseSchemaDialectFor,
   runBashCommand,
   runKindSupportsLiveSteering,
   sanitizeCallTargetText,
+  sanitizeMultilineDisplayText,
   toolPresentationPolicy
-} from "./chunk-CEYBNUGC.js";
+} from "./chunk-4H6ULJ3H.js";
+import {
+  defaultRoutingIntent,
+  sameRouteIdentity
+} from "./chunk-VPTUJU4P.js";
 import {
   createTaskBoardStore,
   foldSessionTaskHistory,
   foldTaskBoard,
   taskBoardCounts
-} from "./chunk-5FR74PWO.js";
-import {
-  DEFAULT_RECENT_ENTRY_LIMIT,
-  assessFinishContract
-} from "./chunk-OBMAI2DP.js";
-import {
-  defaultRoutingIntent,
-  sameRouteIdentity
-} from "./chunk-5C77SEEY.js";
+} from "./chunk-2JDWVJND.js";
 import {
   agentRoleFactsResolver,
   gateDeciderAgentId,
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-UND3GU2L.js";
-import "./chunk-CMZWFGD2.js";
-import "./chunk-I4HZDVNP.js";
-import "./chunk-ZI647VB5.js";
-import "./chunk-JNXPYBB4.js";
-import "./chunk-GH5622CP.js";
-import "./chunk-XN3L4EYL.js";
+} from "./chunk-H7IXIC72.js";
 import {
-  escapeRegExp
-} from "./chunk-VG7TBQIY.js";
-import "./chunk-OQE5J4C6.js";
-import "./chunk-SPULKLCF.js";
-import {
-  SKILL_SUGGESTION_PREFIX,
-  isSkillActivation,
-  skillActivationFromToolDetails
-} from "./chunk-GOXNB3AO.js";
+  DEFAULT_RECENT_ENTRY_LIMIT,
+  assessFinishContract
+} from "./chunk-7C6RYZGQ.js";
+import "./chunk-N3PBVRTZ.js";
+import "./chunk-A2NJGIB3.js";
 import {
-  DEFAULT_AUTONOMY_LEVEL
-} from "./chunk-HWUFFB6L.js";
+  resolveToCwd
+} from "./chunk-OQE5J4C6.js";
 import {
   parseCouncilReport,
   parseOracleResult,
   parseScoutResult,
   parseVerifierResult,
   resultContractSourceId
-} from "./chunk-DJNLUABN.js";
-import "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
 import {
   CLIO_PROJECT_DIR,
   toolMutationPaths
 } from "./chunk-MV3K5QF2.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  SKILL_SUGGESTION_PREFIX,
+  isSkillActivation,
+  skillActivationFromToolDetails
+} from "./chunk-RAPCMZL4.js";
 import {
   VERIFICATION_SCRIPT_FAMILY_HINT
 } from "./chunk-UL3WSD3F.js";
@@ -411,6 +512,9 @@ import {
 } from "./chunk-OZNBF4L3.js";
 import "./chunk-4BJ5BYCE.js";
 import "./chunk-ECH6PKUQ.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
+import "./chunk-ZI647VB5.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
@@ -424,13 +528,14 @@ import {
   incompleteInstallationAdvice
 } from "./chunk-65DEGPJ6.js";
 import "./chunk-M6L6IDJG.js";
-import "./chunk-XAKHZX5N.js";
 import "./chunk-UUVG37B4.js";
 import {
   readCodewiki,
   readCodewikiAsync
 } from "./chunk-LBMZMYH2.js";
+import "./chunk-XAKHZX5N.js";
 import "./chunk-33YXPOE3.js";
+import "./chunk-7CR24IG7.js";
 import {
   getVersionInfo
 } from "./chunk-XPLRXC72.js";
@@ -439,19 +544,20 @@ import {
   InteropDomainModule,
   delegationEntryForKind,
   renderProposalEntry
-} from "./chunk-SROCI7ZU.js";
-import "./chunk-DOOEX22V.js";
+} from "./chunk-QQ7EKM72.js";
+import "./chunk-56KB5IJP.js";
 import {
   source_default
 } from "./chunk-5TSRNF4G.js";
 import {
-  AGENT_ROLE_TOOLS_REQUIRED_REASON,
   ProvidersDomainModule,
   VALID_THINKING_LEVELS,
   applyModelCapabilityPatch,
+  canonicalEndpointKey,
+  endpointCapacitiesForStatuses,
+  endpointCapacityForStatus,
   firstRuntimeResolutionError,
-  formatContextWindowSlots,
-  getRuntimeRegistry,
+  foregroundStreamUsage,
   isDispatchEligibleRuntime,
   isOrchestratorEligibleRuntime,
   modelCandidatesForStatus,
@@ -459,28 +565,22 @@ import {
   modelResidencyForStatus,
   normalizeCostProvenance,
   refineRuntimeTargetWithModelHints,
-  registerBuiltinRuntimes,
+  registerForegroundStream,
+  residencyTargetKey,
   resolveModelCapabilities,
   resolveModelReference,
   resolveModelRuntimeCapabilitiesForProviders,
-  resolveProviderReference,
   resolveReservedOutputTokens,
   resolveRuntimeTarget,
   runtimeResolutionWarningsBesideThinkingNotice,
   runtimeTargetSnapshot,
   setProtectedModelsProvider,
-  supportsAgentRoleTools,
   thinkingLevelChoiceLabel,
   thinkingLevelFromChoiceLabel,
   withRunOverrides
-} from "./chunk-VQNODYQ4.js";
+} from "./chunk-MIX5N5AC.js";
 import "./chunk-CFGTUFWB.js";
-import {
-  targetRequiresAuth
-} from "./chunk-JRIO5UD2.js";
-import {
-  interopAgentKind
-} from "./chunk-IHXBNWMM.js";
+import "./chunk-LU7P4LHA.js";
 import {
   AutoCompactionTrigger,
   DEFAULT_COMPACTION_THRESHOLD,
@@ -492,13 +592,21 @@ import {
   contextUsageSnapshot,
   estimateAgentContextBreakdown,
   estimateAgentContextTokens,
+  estimateAgentMessageTokens,
   estimateReasoningTextTokens,
   extractReasoningTokens,
   getLatestContextSnapshot,
+  lastLoadedContextWindow,
   reconcileSnapshot,
   shouldCompact,
   snapshotInputTokens
-} from "./chunk-GEYXPTRF.js";
+} from "./chunk-AEYBF3TB.js";
+import {
+  interopAgentKind
+} from "./chunk-IHXBNWMM.js";
+import {
+  setGitCommitAttributionEnabled
+} from "./chunk-B5CSFE7B.js";
 import {
   bindAgentProfileInSettings,
   readSettings,
@@ -507,14 +615,18 @@ import {
   setFleetProfileInSettings,
   updateSettings,
   useTargetInSettings
-} from "./chunk-UHXRNZ2J.js";
+} from "./chunk-PNY46YEY.js";
 import {
-  DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS,
-  DEFAULT_SETTINGS,
-  THINKING_LEVELS
-} from "./chunk-4DGYLA73.js";
-import "./chunk-LL4KHSZI.js";
-import "./chunk-SST6Z5JA.js";
+  MAX_TIMER_DELAY_MS,
+  rawDurationMs
+} from "./chunk-FQ4SKYE4.js";
+import {
+  getSharedBus
+} from "./chunk-ZGVHUX3M.js";
+import {
+  BusChannels,
+  isRunAbortedPayload
+} from "./chunk-RKRLDWD3.js";
 import {
   atomicWrite,
   cwdHash,
@@ -522,123 +634,60 @@ import {
   readSessionTailTurns,
   sessionCurrentPath,
   sessionPaths
-} from "./chunk-FO5ZOVUY.js";
-import "./chunk-R346GLFC.js";
+} from "./chunk-KV2AOLDF.js";
+import "./chunk-6EJMN2Y3.js";
 import {
-  setGitCommitAttributionEnabled
-} from "./chunk-D4MDIG46.js";
+  readClioVersion,
+  readPiMonoVersion
+} from "./chunk-IWHMRKLL.js";
 import {
-  MAX_TIMER_DELAY_MS,
-  rawDurationMs
-} from "./chunk-FQ4SKYE4.js";
+  formatContextWindowSlots,
+  registerBuiltinRuntimes
+} from "./chunk-JEQQR47K.js";
+import {
+  DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS,
+  DEFAULT_SETTINGS,
+  THINKING_LEVELS
+} from "./chunk-XDOQXGFO.js";
+import "./chunk-LL4KHSZI.js";
 import {
   configureGuardrails
 } from "./chunk-4ZG3XFUR.js";
+import {
+  resolveProviderReference
+} from "./chunk-774ILSRL.js";
+import {
+  targetRequiresAuth
+} from "./chunk-EQ63NRB7.js";
+import "./chunk-SST6Z5JA.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
-import {
-  StringEnum,
-  cleanupEngineSessionResources,
-  completeEngineText,
-  isEngineRetryableAssistantError,
-  stream
-} from "./chunk-FCSXB6T2.js";
 import "./chunk-APJ265NV.js";
-import "./chunk-YXLYO42X.js";
 import {
   clioConfigDir,
   clioDataDir,
   clioStateDir,
   stateRootRemoved
 } from "./chunk-BNAZZHFG.js";
-import "./chunk-6EJMN2Y3.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
 import {
-  ClioEditor,
-  CombinedAutocompleteProvider,
-  Container,
-  DEFAULT_SELECT_THEME,
-  FILTER_HINT,
-  FocusBox,
-  GLYPH,
-  Input,
-  Markdown,
-  Marked,
-  SGR_DIM,
-  SGR_RESET,
-  ScrollView,
-  SelectList,
-  Text,
-  VStack,
-  abbreviateModelId,
-  barSep,
-  brandMark,
-  buildHint,
-  buildResponsiveHint,
-  clioError,
-  clioTheme,
-  collapseHomePath,
-  createAgentProgress,
-  createKeybindingManager,
-  createProcessInteractiveShell,
-  detectPlatformKeybindingWarnings,
-  detectTerminalKeySupport,
-  dotSep,
-  fgSequence,
-  fitHintEntries,
-  fitUnits,
-  formatCompactMs,
-  formatContextPercent,
-  formatInvalidKeybindingNotice,
-  formatPlatformKeybindingNotice,
-  formatRuntimeResolutionDiagnostic,
-  formatTargetLabel,
-  frame,
-  fuzzyFilter,
-  getActiveRenderTrace,
-  getKeybindings,
-  innerDivider,
-  isClioToken,
-  isKeyRelease,
-  joinChips,
-  joinSections,
-  listGroupHeader,
-  markdownTheme,
-  matchesKey,
-  padAnsi,
-  paintHex,
-  permissionHintEntries,
-  rule,
-  runtimeResolutionDiagnosticLine,
-  screenTitle,
-  sectionTag,
-  selectListTheme,
-  showClioOverlayFrame,
-  spinnerFrame,
-  stripTerminalSequences,
-  truncateToWidth,
-  validateKeybindings,
-  visibleWidth,
-  wrapTextWithAnsi
-} from "./chunk-5C3AQNDW.js";
-import {
-  getTerminationCoordinator
-} from "./chunk-X2KV5FXT.js";
+  getRuntimeRegistry
+} from "./chunk-NUGM5KR6.js";
 import {
-  getSharedBus
-} from "./chunk-ZGVHUX3M.js";
-import {
-  BusChannels,
-  isRunAbortedPayload
-} from "./chunk-OB5HIGJY.js";
-import "./chunk-JVCV3ICN.js";
-import "./chunk-7CR24IG7.js";
+  AGENT_ROLE_TOOLS_REQUIRED_REASON,
+  supportsAgentRoleTools
+} from "./chunk-VO2LKSTM.js";
 import {
-  readClioVersion,
-  readPiMonoVersion
-} from "./chunk-IWHMRKLL.js";
+  StringEnum,
+  cleanupEngineSessionResources,
+  completeEngineText,
+  isEngineRetryableAssistantError,
+  stream,
+  streamSimple
+} from "./chunk-UOSL25KY.js";
+import "./chunk-YXLYO42X.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -3242,7 +3291,8 @@ function safeProbeReason(providers, status) {
   } catch {
     return "not-configured";
   }
-  return status.available && status.health.status === "healthy" ? null : "unreachable";
+  const reachable = status.health.status === "healthy" || status.health.status === "degraded";
+  return status.available && reachable ? null : "unreachable";
 }
 function installPermissionBridge(input) {
   if (!input.toolRegistry) return { unregister: () => {
@@ -4594,10 +4644,29 @@ async function runSideQuestion(input) {
   const { question, ...rest } = input;
   return runOutOfTurnRound({ ...rest, systemPrompt: SIDE_QUESTION_SYSTEM_PROMPT, userText: question });
 }
+function schemaBindingFor(input) {
+  if (input.responseSchema === void 0 || input.runtimeId === void 0) return null;
+  const dialect = responseSchemaDialectFor(input.runtimeId);
+  return dialect === null ? null : { dialect, ...input.responseSchema };
+}
 async function runOutOfTurnRound(input) {
+  const binding = schemaBindingFor(input);
+  if (binding === null) return runRound(input, null);
+  try {
+    return await runRound(input, binding);
+  } catch (error) {
+    if (input.signal?.aborted === true) throw error;
+    if (!isResponseSchemaRejection(error instanceof Error ? error.message : String(error))) throw error;
+    return runRound(input, null);
+  }
+}
+async function runRound(input, binding) {
   const options = { maxTokens: input.maxTokens ?? SIDE_QUESTION_MAX_TOKENS };
   if (input.apiKey !== void 0) options.apiKey = input.apiKey;
   if (input.signal !== void 0) options.signal = input.signal;
+  if (binding !== null) {
+    options.onPayload = (payload) => patchResponseSchemaPayloadForDialect(payload, binding.dialect, binding.schema, binding.name);
+  }
   const context = {
     systemPrompt: input.systemPrompt,
     messages: [
@@ -4647,13 +4716,31 @@ var HANDOFF_SYSTEM_PROMPT = [
   `The object must match this JSON schema exactly: ${JSON.stringify(HANDOFF_RESPONSE_SCHEMA)}`
 ].join(" ");
 var HANDOFF_MAX_TOKENS = 4096;
+var HANDOFF_SCHEMA_NAME = "handoff_record";
+var HANDOFF_REPAIR_QUOTE_CHARS = 600;
+function repairText(goal, repair) {
+  const quoted = repair.previous.slice(0, HANDOFF_REPAIR_QUOTE_CHARS);
+  return [
+    `The next session's goal is: ${goal}`,
+    "",
+    "Your previous answer could not be read as a handoff record.",
+    `The parser said: ${repair.complaint}`,
+    "This is what you returned, verbatim:",
+    "---",
+    quoted.length > 0 ? quoted : "(nothing)",
+    "---",
+    "Answer again with one JSON object matching the schema and nothing else.",
+    "No prose before it, no prose after it, no code fence."
+  ].join("\n");
+}
 async function runHandoffRound(input) {
-  const { goal, ...rest } = input;
+  const { goal, repair, ...rest } = input;
   return runOutOfTurnRound({
     ...rest,
     maxTokens: input.maxTokens ?? HANDOFF_MAX_TOKENS,
     systemPrompt: HANDOFF_SYSTEM_PROMPT,
-    userText: `The next session's goal is: ${goal}
+    responseSchema: { name: HANDOFF_SCHEMA_NAME, schema: HANDOFF_RESPONSE_SCHEMA },
+    userText: repair ? repairText(goal, repair) : `The next session's goal is: ${goal}
 
 Extract the handoff record for that goal now.`
   });
@@ -4860,6 +4947,7 @@ function maskStaleObservations(entries, excludeLastTurns) {
 init_esm_shims();
 import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 import { dirname, join as join4 } from "node:path";
+var PROMPT_MANIFEST_VERSION = 2;
 var SHA256_HEX = /^[a-f0-9]{64}$/;
 function isCanonicalUtcTimestamp(value) {
   if (typeof value !== "string") return false;
@@ -4885,9 +4973,18 @@ function isProjectPreloadClass(value) {
   if (!isRecord6(value)) return false;
   return (value.mode === "full" || value.mode === "synopsis" || value.mode === "none") && isNonNegativeInteger(value.chars) && isNonNegativeInteger(value.lines) && (value.reason === null || value.reason === "size" || value.reason === "lines" || value.reason === "no-clio-md") && typeof value.nearLimit === "boolean" && typeof value.label === "string";
 }
+function isOptional(value, guard) {
+  return value === void 0 || guard(value);
+}
 function isSessionPromptCompileRecord(value) {
   if (!isRecord6(value)) return false;
-  return isCanonicalUtcTimestamp(value.at) && (value.previousHash === null || isSha256(value.previousHash)) && isSha256(value.systemPromptHash) && isNonNegativeInteger(value.tokenEstimate) && (value.thinkingLevel === null || typeof value.thinkingLevel === "string") && (value.projectPreload === null || isProjectPreloadClass(value.projectPreload)) && Array.isArray(value.sections) && value.sections.every(isPromptManifestSection) && Array.isArray(value.fragments) && value.fragments.every(isPromptManifestFragment);
+  return isOptional(value.version, isNonNegativeInteger) && isOptional(
+    value.contextWindow,
+    (candidate) => candidate === null ? true : isNonNegativeInteger(candidate)
+  ) && isOptional(
+    value.contextWindowSource,
+    (candidate) => candidate === null ? true : typeof candidate === "string"
+  ) && isCanonicalUtcTimestamp(value.at) && (value.previousHash === null || isSha256(value.previousHash)) && isSha256(value.systemPromptHash) && isNonNegativeInteger(value.tokenEstimate) && (value.thinkingLevel === null || typeof value.thinkingLevel === "string") && (value.projectPreload === null || isProjectPreloadClass(value.projectPreload)) && Array.isArray(value.sections) && value.sections.every(isPromptManifestSection) && Array.isArray(value.fragments) && value.fragments.every(isPromptManifestFragment);
 }
 function getPromptManifestFilePath(meta, stateDir) {
   const safeMeta = {
@@ -4935,6 +5032,9 @@ function readPromptCompileManifest(meta, stateDir) {
     };
   }
 }
+function readPromptCompileRecords(meta) {
+  return readPromptCompileManifest(meta).records;
+}
 
 // src/interactive/model-session-replay.ts
 init_esm_shims();
@@ -5055,6 +5155,160 @@ function formatRetryStatus(status) {
 // src/interactive/renderers/tool-execution.ts
 init_esm_shims();
 
+// src/interactive/mutation-preview.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync5 } from "node:fs";
+var MUTATION_PREVIEW_VISIBLE_ROWS = 16;
+var MUTATION_PREVIEW_MAX_CHARS = 262144;
+function canonicalJson(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return "null";
+}
+function callArgumentsDigest(args) {
+  return createHash2("sha256").update(canonicalJson(args ?? {}), "utf8").digest("hex").slice(0, 16);
+}
+function readEdits(value) {
+  if (!Array.isArray(value)) return null;
+  const edits = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+    const record2 = entry;
+    if (typeof record2.oldText !== "string" || typeof record2.newText !== "string") return null;
+    edits.push({ oldText: record2.oldText, newText: record2.newText });
+  }
+  return edits;
+}
+function mutationFacts(tool, args) {
+  if (!args || typeof args.path !== "string" || args.path.length === 0) return null;
+  if (tool === ToolNames.Write) {
+    if (typeof args.content !== "string") return null;
+    return {
+      kind: "write",
+      bytes: Buffer.byteLength(args.content, "utf8"),
+      replacements: 1,
+      digest: callArgumentsDigest(args)
+    };
+  }
+  if (tool === ToolNames.Edit) {
+    const edits = readEdits(args.edits);
+    if (edits === null || edits.length === 0) return null;
+    const bytes = edits.reduce((total, edit) => total + Buffer.byteLength(edit.newText, "utf8"), 0);
+    return { kind: "edit", bytes, replacements: edits.length, digest: callArgumentsDigest(args) };
+  }
+  return null;
+}
+function mutationFactsLine(facts) {
+  const shape = facts.kind === "write" ? `write ${facts.bytes} B` : `edit ${facts.replacements} replacement${facts.replacements === 1 ? "" : "s"} \xB7 ${facts.bytes} B`;
+  return `${shape} \xB7 sha256 ${facts.digest}`;
+}
+function numberedLines(text) {
+  const raw = text.split("\n");
+  const width = String(raw.length).length;
+  return raw.map((line, index) => `${String(index + 1).padStart(width, " ")} ${line}`);
+}
+function boundedContent(content) {
+  if (content.length <= MUTATION_PREVIEW_MAX_CHARS) return { text: content, withheld: 0 };
+  return {
+    text: content.slice(0, MUTATION_PREVIEW_MAX_CHARS),
+    withheld: content.length - MUTATION_PREVIEW_MAX_CHARS
+  };
+}
+function previewFrom(facts, heading, text, options = {}) {
+  const clean = sanitizeMultilineDisplayText(text);
+  const body = options.numbered ? numberedLines(clean.text) : clean.text.split("\n");
+  if (options.trailer !== void 0) body.push(options.trailer);
+  return {
+    facts,
+    heading,
+    body,
+    neutralized: clean.neutralized,
+    tabsExpanded: clean.tabsExpanded
+  };
+}
+function refusal(facts, heading, reason) {
+  return { facts, heading, body: [reason], neutralized: false, tabsExpanded: false };
+}
+function replacementListing(edits) {
+  const blocks = [];
+  for (const [index, edit] of edits.entries()) {
+    blocks.push(`@@ replacement ${index + 1} of ${edits.length}`);
+    for (const line of normalizeToLF(edit.oldText).split("\n")) blocks.push(`- ${line}`);
+    for (const line of normalizeToLF(edit.newText).split("\n")) blocks.push(`+ ${line}`);
+  }
+  return blocks.join("\n");
+}
+function editPreview(facts, path, edits, read) {
+  let current;
+  try {
+    current = read(resolveToCwd(path));
+  } catch (error) {
+    const message = sanitizeCallTargetText(error instanceof Error ? error.message : String(error));
+    return previewFrom(
+      facts,
+      `Requested replacements for ${sanitizeCallTargetText(path)} (the file could not be read: ${message})`,
+      replacementListing(edits)
+    );
+  }
+  try {
+    const { text } = stripBom(current);
+    const applied = applyEditsToNormalizedContent(normalizeToLF(text), edits, path);
+    const diff = generateDiffString(applied.baseContent, applied.newContent);
+    return previewFrom(facts, `Effective diff for ${sanitizeCallTargetText(path)}`, diff.diff);
+  } catch (error) {
+    const message = sanitizeCallTargetText(error instanceof Error ? error.message : String(error));
+    return previewFrom(
+      facts,
+      `Requested replacements for ${sanitizeCallTargetText(path)} (they do not apply: ${message})`,
+      replacementListing(edits)
+    );
+  }
+}
+function createMutationInspector(tool, args, facts, options = {}) {
+  const read = options.readFile ?? ((path) => readFileSync5(path, "utf8"));
+  return () => {
+    const current = mutationFacts(tool, args);
+    if (current === null || current.digest !== facts.digest) {
+      return refusal(
+        facts,
+        "Preview unavailable",
+        `These arguments no longer digest to sha256 ${facts.digest}. Deny this call rather than approving bytes that cannot be shown.`
+      );
+    }
+    const path = typeof args?.path === "string" ? args.path : "";
+    if (facts.kind === "write") {
+      const content = typeof args?.content === "string" ? args.content : "";
+      const bounded = boundedContent(content);
+      return previewFrom(facts, `Proposed content for ${sanitizeCallTargetText(path)}`, bounded.text, {
+        numbered: true,
+        ...bounded.withheld > 0 ? { trailer: `\u2026 ${bounded.withheld} more characters not shown (preview capped at ${MUTATION_PREVIEW_MAX_CHARS})` } : {}
+      });
+    }
+    const edits = readEdits(args?.edits) ?? [];
+    return editPreview(facts, path, edits, read);
+  };
+}
+function mutationPreviewWindow(lines, scroll, rows = MUTATION_PREVIEW_VISIBLE_ROWS) {
+  const visible = Math.max(1, rows);
+  const maxScroll = Math.max(0, lines.length - visible);
+  const start = Math.max(0, Math.min(scroll, maxScroll));
+  const window = lines.slice(start, start + visible);
+  if (lines.length <= visible) return { window, position: null, maxScroll };
+  return {
+    window,
+    position: `(${start + 1}-${start + window.length} of ${lines.length} lines)`,
+    maxScroll
+  };
+}
+
 // src/interactive/renderers/diff.ts
 init_esm_shims();
 var ESC = String.fromCharCode(27);
@@ -5529,7 +5783,10 @@ function renderToolAwaitingApproval(call, width, view) {
   const facts = [
     ["action", view.actionClass],
     ["axis", axis],
-    ...view.target !== void 0 && view.target.length > 0 ? [["target", view.target]] : []
+    ...view.target !== void 0 && view.target.length > 0 ? [["target", view.target]] : [],
+    // Size and digest, never the mutation text: this row is the transcript,
+    // which is written, replayed, and shared (issue #254).
+    ...view.mutation !== void 0 ? [["mutation", mutationFactsLine(view.mutation)]] : []
   ];
   for (const [label, value] of facts) {
     lines.push(...indentAndWrap(`${dim(`${label} \xB7`)} ${value}`, width, false));
@@ -6565,12 +6822,12 @@ function toggledFold(effective) {
 
 // src/interactive/worker-receipts.ts
 init_esm_shims();
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // src/interactive/view/artifacts.ts
 init_esm_shims();
-import { createReadStream, readFileSync as readFileSync5, statSync } from "node:fs";
+import { createReadStream, readFileSync as readFileSync6, statSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute4, join as join5, relative as relative4, resolve as resolve3, sep } from "node:path";
 
@@ -6649,7 +6906,7 @@ var CONTEXT_CATEGORY_TOKEN = {
   project: "muted",
   messages: "accent",
   pending: "accentDeep",
-  reserve: "dim",
+  reserve: "frame",
   free: "frame",
   streaming: "accent"
 };
@@ -7513,6 +7770,18 @@ function progressAnswerLines(theme6, progress, runId, contentWidth) {
   }
   return body.map((row2, index) => `${index === 0 ? cardKvKey(theme6, "answer") : " ".repeat(gutter)}${row2}`);
 }
+function trustCardLines(theme6, row2, contentWidth) {
+  const gutter = CARD_KV_KEY_WIDTH + 1;
+  const valueWidth = Math.max(1, contentWidth - gutter);
+  const trust = row2.trust === void 0 ? theme6.fg("dim", isTerminalStatus(row2.status) ? "receipt not read back" : "not sealed yet") : theme6.fg(
+    trustVerdictToken(row2.trust.verdict),
+    `${trustVerdictGlyph(row2.trust.verdict)} ${row2.trust.verdict}; ${row2.trust.text}`
+  );
+  const host = row2.hostVerification === void 0 ? "" : ` \xB7 ${theme6.fg("muted", `host checks ${row2.hostVerification}`)}`;
+  return wrapTextWithAnsi(`${trust}${host}`, valueWidth).map(
+    (line, index) => `${index === 0 ? cardKvKey(theme6, "trust") : " ".repeat(gutter)}${line}`
+  );
+}
 function renderDispatchCard(row2, width, evidence, options = {}) {
   const theme6 = clioTheme();
   const contentWidth = Math.max(0, width - 4);
@@ -7544,13 +7813,13 @@ function renderDispatchCard(row2, width, evidence, options = {}) {
   const statusUnits = [
     statusStr,
     theme6.fg("muted", `node ${row2.node ?? "local"}`),
+    ...row2.endpoint !== void 0 ? [theme6.fg("info", `slots ${options.endpointActive ?? 0}/${row2.endpoint.limit} ${row2.endpoint.label}`)] : [],
     ...row2.gate !== void 0 ? [theme6.fg("info", `gate ${row2.gate.role} c${row2.gate.cycle}`)] : [],
     ...row2.rerouteCount !== void 0 && row2.rerouteCount > 0 ? [theme6.fg("warning", `rerouted x${row2.rerouteCount}`)] : [],
     ...row2.failoverHops !== void 0 && row2.failoverHops > 0 ? [theme6.fg("warning", `failed over x${row2.failoverHops}`)] : [],
     `${theme6.fg("dim", "ttft")} ${theme6.fg("muted", ttft)}`,
     `${theme6.fg("dim", "cost")} ${theme6.fg("muted", cost)}`
   ];
-  const hostVerification = theme6.fg("info", `host_verification=${row2.hostVerification ?? "not_requested"}`);
   const contextUnit = formatWorkerContextMeter(row2.lastContextTokens ?? 0, row2.contextWindow, theme6);
   const phaseCell = formatDispatchPhaseCell(row2.phase, contentWidth);
   const bodyLines2 = [
@@ -7564,7 +7833,7 @@ function renderDispatchCard(row2, width, evidence, options = {}) {
     targetLine,
     ...row2.taskSummary ? [truncateToWidth(`${cardKvKey(theme6, "task")}${theme6.fg("muted", row2.taskSummary)}`, contentWidth, "\u2026", false)] : [],
     cardUnitsLine(theme6, "status", statusUnits, contentWidth),
-    cardUnitsLine(theme6, "evidence", [hostVerification], contentWidth),
+    ...trustCardLines(theme6, row2, contentWidth),
     ...row2.budget !== void 0 ? [
       truncateToWidth(
         `${cardKvKey(theme6, "policy")}${theme6.fg("muted", `${formatBudgetPolicy(row2.budget)}; requested ${formatBudgetRequest(row2.budget)}`)}`,
@@ -7619,6 +7888,16 @@ function renderDispatchCard(row2, width, evidence, options = {}) {
       )
     );
   }
+  if (row2.writeRecordDowngrade) {
+    const warning = describeWriteBoundaryAttributionDowngrade({
+      ...row2.writeRecordDowngrade,
+      runId: row2.runId,
+      stepId: row2.phase?.stepId ?? null
+    });
+    bodyLines2.push(
+      ...wrapTextWithAnsi(`${cardKvKey(theme6, "record")}${theme6.fg("warning", `open: ${warning}`)}`, contentWidth)
+    );
+  }
   if (evidence) {
     const proofLine = evidenceCardLine(theme6, evidence, contentWidth);
     if (proofLine !== null) bodyLines2.push(proofLine);
@@ -7757,10 +8036,17 @@ function formatDispatchBoardLines(rows, width = 76, observability, selectedRunId
       return theme6.fg("dim", " ".repeat(padding) + line);
     });
   }
+  const endpointActive = { ...foregroundStreamUsage() };
+  for (const row2 of rows) {
+    if (row2.endpoint !== void 0 && (row2.status === "running" || row2.status === "stale" || row2.status === "enqueued" || row2.status === "cancelling")) {
+      endpointActive[row2.endpoint.key] = (endpointActive[row2.endpoint.key] ?? 0) + 1;
+    }
+  }
   const cards = dispatchBoardItems(rows, selectedRunId).map(
     (item) => item.kind === "council" ? renderCouncilCard(item.group, width) : renderDispatchCard(item.row, width, deriveRunEvidenceState(observability, item.row.runId), {
       selected: item.row.runId === selectedRunId,
-      expanded: detailExpanded && item.row.runId === selectedRunId
+      expanded: detailExpanded && item.row.runId === selectedRunId,
+      ...item.row.endpoint !== void 0 ? { endpointActive: endpointActive[item.row.endpoint.key] ?? 0 } : {}
     })
   );
   const body = [];
@@ -7884,6 +8170,14 @@ function parseGateBadge(value) {
   const cycle = parsePositiveInt(record2.cycle) ?? 1;
   return { role: record2.role, cycle };
 }
+function parseEndpointCapacity(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record2 = value;
+  const key = parseNonEmptyString(record2.key);
+  const label = parseNonEmptyString(record2.label);
+  const limit = parsePositiveInt(record2.limit);
+  return key === void 0 || label === void 0 || limit === void 0 ? void 0 : { key, label, limit };
+}
 function parseCouncilBadge(value) {
   if (typeof value !== "object" || value === null) return void 0;
   const record2 = value;
@@ -7906,6 +8200,30 @@ function parseOptionalDetail(value) {
   const detail = value.replace(/\s+/g, " ").trim();
   return detail.length > 0 ? detail : null;
 }
+function trustVerdictToken(verdict) {
+  switch (verdict) {
+    case "reviewed":
+      return "success";
+    case "grounded":
+      return "info";
+    case "unverified":
+      return "muted";
+    case "compromised":
+      return "error";
+    default:
+      return "dim";
+  }
+}
+function trustVerdictGlyph(verdict) {
+  switch (verdict) {
+    case "reviewed":
+      return GLYPH.ok;
+    case "compromised":
+      return GLYPH.error;
+    default:
+      return "\u25C7";
+  }
+}
 function terminalDetail(row2) {
   if (row2.status !== "failed" && row2.status !== "dead" && row2.status !== "aborted") return null;
   return parseOptionalDetail(row2.outcomeDetail);
@@ -8011,6 +8329,7 @@ function toRow(entry, now) {
     runtimeId: entry.runtimeId,
     targetId: entry.targetId,
     wireModelId: entry.wireModelId,
+    ...entry.endpoint !== void 0 ? { endpoint: { ...entry.endpoint } } : {},
     ...entry.taskSummary !== void 0 ? { taskSummary: entry.taskSummary } : {},
     ...entry.budget !== void 0 ? { budget: entry.budget } : {},
     status: retry ? "retrying" : entry.status,
@@ -8026,6 +8345,7 @@ function toRow(entry, now) {
     ...entry.gate !== void 0 ? { gate: { ...entry.gate } } : {},
     ...entry.council !== void 0 ? { council: { ...entry.council } } : {},
     ...entry.hostVerification !== void 0 ? { hostVerification: entry.hostVerification } : {},
+    ...entry.trust !== void 0 ? { trust: entry.trust } : {},
     ...entry.rerouteCount !== void 0 ? { rerouteCount: entry.rerouteCount } : {},
     ...entry.failoverHops !== void 0 ? { failoverHops: entry.failoverHops } : {},
     ...entry.contextWindow !== void 0 ? { contextWindow: entry.contextWindow } : {},
@@ -8037,7 +8357,8 @@ function toRow(entry, now) {
     currentTool: retry ? null : progress.currentAction?.tool ?? null,
     recentTools: progress.recentActions.map((action) => action.tool),
     ...retry ? { retry: { ...retry } } : {},
-    ...entry.steerAcknowledgement ? { steerAcknowledgement: { ...entry.steerAcknowledgement } } : {}
+    ...entry.steerAcknowledgement ? { steerAcknowledgement: { ...entry.steerAcknowledgement } } : {},
+    ...entry.writeRecordDowngrade ? { writeRecordDowngrade: { ...entry.writeRecordDowngrade } } : {}
   };
 }
 function sortEntries(a, b) {
@@ -8066,8 +8387,10 @@ function createDispatchBoardStore(bus, snapshot, readReceipt) {
   let nextSequence = 0;
   let reconciledAtMs = Date.now();
   const settleFromReceipt = (entry) => {
-    const text = readReceipt?.(entry.runId)?.text;
+    const facts = readReceipt?.(entry.runId);
+    const text = facts?.text;
     entry.progress.settle(typeof text === "string" && text.trim().length > 0 ? text : void 0);
+    if (facts?.trust !== void 0) entry.trust = summarizeTrustStatus(facts.trust);
   };
   const upsertBase = (raw, status, now) => {
     const runId = parseRunId(raw.runId);
@@ -8076,6 +8399,7 @@ function createDispatchBoardStore(bus, snapshot, readReceipt) {
     const agentAudience = parseAgentAudience(raw.agentAudience, previous?.agentAudience);
     const requestOrigin = parseRequestOrigin(raw.requestOrigin, previous?.requestOrigin);
     const node = parseNonEmptyString(raw.node) ?? previous?.node;
+    const endpoint = parseEndpointCapacity(raw.endpoint) ?? previous?.endpoint;
     const gate = parseGateBadge(raw.gate) ?? previous?.gate;
     const council = parseCouncilBadge(raw.council) ?? previous?.council;
     const rerouteCount = parsePositiveInt(raw.rerouteCount) ?? previous?.rerouteCount;
@@ -8092,6 +8416,7 @@ function createDispatchBoardStore(bus, snapshot, readReceipt) {
       runtimeId: parseText(raw.runtimeId, previous?.runtimeId ?? "-"),
       targetId: parseText(raw.targetId, previous?.targetId ?? "-"),
       wireModelId: parseText(raw.wireModelId, previous?.wireModelId ?? "-"),
+      ...endpoint !== void 0 ? { endpoint } : {},
       ...taskSummary !== void 0 ? { taskSummary } : {},
       ...budget !== void 0 ? { budget } : {},
       status,
@@ -8119,7 +8444,8 @@ function createDispatchBoardStore(bus, snapshot, readReceipt) {
       ...phase !== void 0 ? { phase } : {},
       progress: previous?.progress ?? createWorkerProgressFold(),
       ...previous?.retry ? { retry: { ...previous.retry } } : {},
-      ...previous?.steerAcknowledgement ? { steerAcknowledgement: { ...previous.steerAcknowledgement } } : {}
+      ...previous?.steerAcknowledgement ? { steerAcknowledgement: { ...previous.steerAcknowledgement } } : {},
+      ...previous?.writeRecordDowngrade ? { writeRecordDowngrade: { ...previous.writeRecordDowngrade } } : {}
     };
     entries.set(runId, entry);
     pruneEntries(entries, (evicted) => fleetPhases.delete(evicted));
@@ -8246,6 +8572,19 @@ function createDispatchBoardStore(bus, snapshot, readReceipt) {
           entry.ttftMs = Math.round(performance3.now() - entry.startedAtClockMs);
         }
       }
+      if (type === "clio_write_record_downgraded") {
+        const rawPayload = workerEvent.payload;
+        const payload2 = typeof rawPayload === "object" && rawPayload !== null ? rawPayload : null;
+        const tool = payload2 === null ? void 0 : parseNonEmptyString(payload2.tool);
+        const toolCallId = payload2 === null ? void 0 : parseNonEmptyString(payload2.toolCallId);
+        if (payload2?.reason === "opaque_tool_succeeded" && tool !== void 0 && toolCallId !== void 0) {
+          entry.writeRecordDowngrade = {
+            reason: "opaque_tool_succeeded",
+            tool: sanitizeCallTargetText(tool),
+            toolCallId: sanitizeCallTargetText(toolCallId)
+          };
+        }
+      }
       entry.progress.observe(payload.event);
       if (type === "clio_steer_received") {
         const steerPayload = workerEvent.payload;
@@ -8689,8 +9028,41 @@ function retryOverlay(status) {
 }
 function reduceStatus(prev, event, ctx) {
   switch (event.type) {
-    case "agent_start":
+    // A consumed prompt occupies `preparing` before any engine event exists,
+    // and the previous turn's summary rides along untouched: a refused
+    // admission puts the footer back on the last turn that actually ran,
+    // which is still the truth about what happened.
+    case "submit_accepted":
       if (isActive(prev.phase)) return prev;
+      return {
+        ...prev,
+        phase: "preparing",
+        since: ctx.now,
+        lastMeaningfulAt: ctx.now,
+        localRuntime: ctx.localRuntime,
+        preparingSubmission: true,
+        watchdogTier: 0,
+        resumePhase: void 0,
+        activePhases: void 0,
+        overlayStack: [],
+        tool: void 0,
+        toolStartedAt: void 0,
+        retry: void 0,
+        dispatch: void 0
+      };
+    case "submit_settled":
+      if (prev.preparingSubmission !== true) return prev;
+      return {
+        ...prev,
+        phase: prev.summary ? "ended" : "idle",
+        since: ctx.now,
+        preparingSubmission: void 0,
+        resumePhase: void 0,
+        activePhases: void 0,
+        overlayStack: []
+      };
+    case "agent_start":
+      if (isActive(prev.phase) && prev.preparingSubmission !== true) return prev;
       return {
         ...INITIAL_STATUS,
         phase: "preparing",
@@ -9010,6 +9382,13 @@ function createStatusController(deps) {
     }
     notify(prev, status, force);
   };
+  if (deps.chat.onTurnPreparation) {
+    unsubscribes.push(
+      deps.chat.onTurnPreparation((phase) => {
+        apply({ type: phase === "idle" ? "submit_settled" : "submit_accepted" }, true);
+      })
+    );
+  }
   unsubscribes.push(
     deps.chat.onEvent((event) => {
       if (event.type === "agent_status") return;
@@ -10104,7 +10483,7 @@ function runLedgerPath(stateDir) {
 }
 function readRunLedger(stateDir) {
   try {
-    const raw = readFileSync5(runLedgerPath(stateDir), "utf8").trim();
+    const raw = readFileSync6(runLedgerPath(stateDir), "utf8").trim();
     if (raw.length === 0) return [];
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter(isRecord9) : [];
@@ -10146,6 +10525,15 @@ function validateToolStats(value) {
   }
   return { ok: true };
 }
+function receiptTrustDetail(stateDir, runId) {
+  try {
+    const receipt = JSON.parse(readFileSync6(receiptFilePath(stateDir, runId), "utf8"));
+    const ledger = readRunEnvelope(stateDir, runId);
+    return formatTrustSummaryLine(inspectRunReceiptTrustStatus(receipt, ledger.ok ? ledger.envelope : null).status);
+  } catch {
+    return "integrity verified; trust status unreadable";
+  }
+}
 function readRunEnvelope(stateDir, runId) {
   const runs = readRunLedger(stateDir);
   for (const entry of runs) {
@@ -10157,7 +10545,7 @@ function verifyReceiptFile(stateDir, runId) {
   const target = receiptFilePath(stateDir, runId);
   let raw;
   try {
-    raw = readFileSync5(target, "utf8");
+    raw = readFileSync6(target, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") return { ok: false, reason: "receipt file not found" };
@@ -10252,6 +10640,8 @@ function verifyReceiptFile(stateDir, runId) {
   if (!isNullableString(r.sessionId)) {
     return { ok: false, reason: `sessionId invalid: ${String(r.sessionId)}` };
   }
+  const retired = retiredReceiptIntegrity(r.integrity);
+  if (retired !== null) return { ok: false, reason: retiredReceiptIntegrityReason(retired), retired };
   if (!isReceiptIntegrity(r.integrity)) {
     return { ok: false, reason: "integrity invalid" };
   }
@@ -10507,8 +10897,10 @@ var ReceiptArtifactProvider = class {
         load: () => loadJsonFileLines(path),
         verify: async () => {
           const result = verifyReceiptFile(this.deps.stateDir, env.id);
-          if (!result.ok) return { ok: false, detail: result.reason };
-          return { ok: true, detail: "integrity verified" };
+          if (!result.ok) {
+            return { ok: false, detail: result.reason, ...result.retired !== void 0 ? { retired: true } : {} };
+          }
+          return { ok: true, detail: receiptTrustDetail(this.deps.stateDir, env.id) };
         }
       };
     });
@@ -11278,12 +11670,19 @@ function workerReceiptFacts(receipt) {
   };
 }
 function readReceiptFileFacts(runId, stateDir) {
+  let parsed;
   try {
-    const parsed = JSON.parse(readFileSync6(receiptFilePath(stateDir, runId), "utf8"));
-    return isRecord10(parsed) ? workerReceiptFacts(parsed) : null;
+    parsed = JSON.parse(readFileSync7(receiptFilePath(stateDir, runId), "utf8"));
   } catch {
     return null;
   }
+  if (!isRecord10(parsed)) return null;
+  const facts = workerReceiptFacts(parsed);
+  if (facts === null) return null;
+  const row2 = findRunRow(runId, stateDir);
+  if (row2 === null) return facts;
+  const trust = inspectRunReceiptTrustStatus(parsed, row2).status;
+  return { ...facts, trust };
 }
 function readWorkerReceiptFacts(runId, stateDir = clioStateDir()) {
   return readReceiptFileFacts(runId, stateDir);
@@ -11292,7 +11691,7 @@ function findRunRow(runId, stateDir) {
   const path = join6(stateDir, "runs.json");
   if (!existsSync5(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf8"));
     if (!Array.isArray(parsed)) return null;
     for (const entry of parsed) {
       if (isRecord10(entry) && entry.id === runId) return entry;
@@ -12469,18 +12868,27 @@ function createTurnContext(deps) {
   const { state, middleware } = deps;
   const compactionTrigger = new AutoCompactionTrigger();
   let currentContextSnapshot = null;
+  let reconciledAnchor = null;
   let lastCompactionEvent = null;
   let lastPromptCache = null;
   let lastSystemPromptReused = false;
+  let lastPrewarm = null;
   let sessionPrompt = null;
   let sessionPromptKey = null;
+  let sessionPromptHash = null;
+  let resumedPromptHashRead = false;
+  let resumedPromptHash = null;
   const sessionWorkingContextPaths = /* @__PURE__ */ new Set();
   let pendingPromptLogEntry = null;
   let emptyAutoCompactTurnId = null;
   const pendingColdReasons = /* @__PURE__ */ new Set();
   let runExpectedColdReasons = [];
   let nextAssistantColdReasons = [];
-  const TIER_INDEPENDENT_COLD_REASONS = /* @__PURE__ */ new Set(["working_set_evict"]);
+  const TIER_INDEPENDENT_COLD_REASONS = /* @__PURE__ */ new Set([
+    "working_set_evict",
+    "tool_surface_change",
+    "prompt_recompiled"
+  ]);
   const stampsOnTier = (reason, runtimeId) => TIER_INDEPENDENT_COLD_REASONS.has(reason) || runtimeId !== void 0 && deps.providers.getRuntime(runtimeId)?.tier === "local-native";
   const noteColdReason = (reason) => {
     if (!state.streaming) {
@@ -12504,6 +12912,21 @@ function createTurnContext(deps) {
         noteColdReason("compaction");
       }) ?? null
     ),
+    deps.bus?.on(BusChannels.ResidencyMutation, (payload) => {
+      const runtime = state.runtime;
+      const model = runtime?.agent.state.model;
+      const baseUrl = typeof model?.baseUrl === "string" ? model.baseUrl : null;
+      if (payload.targetKey !== residencyTargetKey(runtime?.runtimeId ?? "", baseUrl)) return;
+      noteColdReason("residency");
+    }) ?? null,
+    // A memory step on another endpoint disturbs nothing here, so the stamp is
+    // gated on the step having called the very server this session streams to.
+    deps.bus?.on(BusChannels.MemoryStepCompleted, (payload) => {
+      const target = state.runtime?.runtimeResolution.target;
+      if (target === void 0) return;
+      if (canonicalEndpointKey(target) !== payload.endpointKey) return;
+      noteColdReason("background_memory");
+    }) ?? null,
     deps.bus?.on(BusChannels.ContextRecalled, (payload) => {
       middleware.fireCompactionHook("working_set_recall", payload.trigger);
     }) ?? null
@@ -12558,6 +12981,23 @@ function createTurnContext(deps) {
     }
     return ceilChars(snapshot.pendingUserInput.length);
   };
+  const rememberedLoadedContextWindow = (targetId, modelId) => {
+    const session = deps.session?.current();
+    if (!session) return null;
+    return lastLoadedContextWindow(session, targetId, modelId);
+  };
+  const lastRecordedPromptHash = () => {
+    if (resumedPromptHashRead) return resumedPromptHash;
+    resumedPromptHashRead = true;
+    const currentSession = deps.session?.current();
+    if (!currentSession) {
+      resumedPromptHashRead = false;
+      return null;
+    }
+    const records = readPromptCompileRecords(currentSession);
+    resumedPromptHash = records[records.length - 1]?.systemPromptHash ?? null;
+    return resumedPromptHash;
+  };
   const resolveWindowWithoutRuntime = () => {
     const settings = deps.getSettings();
     const targetId = settings.orchestrator?.target?.trim();
@@ -12569,7 +13009,8 @@ function createTurnContext(deps) {
       requestedThinkingLevel: settings.orchestrator?.thinkingLevel ?? "off",
       use: "orchestrator",
       requireTools: false,
-      requireOutputBudget: true
+      requireOutputBudget: true,
+      knownLoadedContextWindow: rememberedLoadedContextWindow(targetId, wireModelId)
     });
     return resolved.ok ? resolved.target.contextWindowDetails : null;
   };
@@ -12602,6 +13043,19 @@ function createTurnContext(deps) {
     }
     return { contextWindow: 0, contextWindowSource: null, contextWindowSlots: null };
   };
+  const reconciledAnchoredTokens = (agentRuntime, pendingUserTokens) => {
+    const anchor = reconciledAnchor;
+    if (!anchor) return null;
+    const messages = agentRuntime.agent.state.messages;
+    if (anchor.anchoredMessageCount > messages.length) return null;
+    let tail = 0;
+    for (let i = anchor.anchoredMessageCount; i < messages.length; i += 1) {
+      const message = messages[i];
+      if (message === void 0) continue;
+      tail += estimateAgentMessageTokens(message);
+    }
+    return anchor.tokens + tail + pendingUserTokens;
+  };
   const liveContextEstimate = (agentRuntime, pendingUserText) => {
     const contextWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
     const estimateInput = {
@@ -12610,10 +13064,25 @@ function createTurnContext(deps) {
       tools: agentRuntime.agent.state.tools,
       ...pendingUserText !== void 0 ? { pendingUserText } : {}
     };
+    const breakdown = estimateAgentContextBreakdown(estimateInput);
+    const estimatedTokens = estimateAgentContextTokens(estimateInput);
+    const reconciledTokens = reconciledAnchoredTokens(agentRuntime, breakdown.pendingUserTokens);
     return {
-      tokens: estimateAgentContextTokens(estimateInput),
+      // The estimate is a floor, not a competing verdict: it prices material
+      // the attested call never saw, so a provider count below it would be
+      // answering about a smaller conversation.
+      tokens: Math.max(estimatedTokens, reconciledTokens ?? 0),
+      estimatedTokens,
+      reconciledTokens,
       contextWindow,
-      breakdown: estimateAgentContextBreakdown(estimateInput)
+      breakdown
+    };
+  };
+  const carryReconciledAnchorThroughProjection = (agentRuntime, tokensRemoved) => {
+    if (!reconciledAnchor) return;
+    reconciledAnchor = {
+      tokens: Math.max(0, reconciledAnchor.tokens - Math.max(0, tokensRemoved)),
+      anchoredMessageCount: agentRuntime.agent.state.messages.length
     };
   };
   const refreshAgentMessagesFromSession = (agentRuntime) => {
@@ -12627,7 +13096,7 @@ function createTurnContext(deps) {
   const emitCompactionActivity = (status, message) => {
     deps.bus?.emit(BusChannels.ContextActivity, {
       kind: "compaction",
-      phase: "done",
+      phase: status === "completed" ? "done" : "compact",
       status,
       message,
       at: Date.now()
@@ -12694,6 +13163,7 @@ function createTurnContext(deps) {
             emitCompactionActivity("started", "compacting context (mask stage)");
             deps.session.replaceEntries(masked.entries);
             refreshAgentMessagesFromSession(agentRuntime);
+            reconciledAnchor = null;
             deps.bus?.emit(BusChannels.CompactionEnd, { trigger, at: Date.now() });
             const postMaskSnapshot = captureRuntimeContextSnapshot(
               agentRuntime,
@@ -12772,6 +13242,7 @@ function createTurnContext(deps) {
               });
               noteColdReason("working_set_evict");
               refreshAgentMessagesFromSession(agentRuntime);
+              carryReconciledAnchorThroughProjection(agentRuntime, planned.tokensBefore - planned.tokensAfter);
               const postEvictionSnapshot = captureRuntimeContextSnapshot(
                 agentRuntime,
                 state.activeUserTurnId || "compaction",
@@ -12847,6 +13318,7 @@ function createTurnContext(deps) {
     deps.bus?.emit(BusChannels.CompactionEnd, { trigger, at: Date.now() });
     recordCompactionUsage(agentRuntime, result);
     refreshAgentMessagesFromSession(agentRuntime);
+    reconciledAnchor = null;
     const postCompactSnapshot = captureRuntimeContextSnapshot(
       agentRuntime,
       state.activeUserTurnId || "compaction",
@@ -12899,6 +13371,7 @@ function createTurnContext(deps) {
     captureRuntimeContextSnapshot,
     persistContextSnapshot,
     liveContextEstimate,
+    rememberedLoadedContextWindow,
     refreshAgentMessagesFromSession,
     runAutoCompact,
     setCurrentSnapshot(snapshot) {
@@ -12909,6 +13382,14 @@ function createTurnContext(deps) {
       persistContextSnapshot(currentContextSnapshot);
     },
     reconcileUsage(usage) {
+      const promptTokens = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
+      const messages = state.runtime?.agent.state.messages;
+      if (promptTokens > 0 && messages) {
+        reconciledAnchor = {
+          tokens: promptTokens + (usage.output || 0),
+          anchoredMessageCount: messages.length
+        };
+      }
       if (!currentContextSnapshot) return;
       currentContextSnapshot = reconcileSnapshot(currentContextSnapshot, usage);
       snapshotPersistPending = true;
@@ -12936,7 +13417,10 @@ function createTurnContext(deps) {
         return sessionPrompt;
       }
       const modelState = agentRuntime.agent.state.model;
-      const contextWindow = typeof modelState?.contextWindow === "number" ? modelState.contextWindow : null;
+      const windowDetails = agentRuntime.runtimeResolution.contextWindowDetails;
+      const resolvedWindow = windowDetails.effectiveContextWindow;
+      const contextWindow = typeof resolvedWindow === "number" && resolvedWindow > 0 ? resolvedWindow : null;
+      const contextWindowSource = contextWindow === null ? null : windowDetails.contextWindowSource;
       const guidance = modelState?.clio?.quirks?.thinking?.guidance;
       const toolNames = toolNamesFromAgentState(agentRuntime.agent.state.tools);
       const toolPromptHints = toolNames.flatMap((name) => {
@@ -12969,16 +13453,19 @@ function createTurnContext(deps) {
           cwd: process.cwd(),
           workingContextPaths: [...sessionWorkingContextPaths]
         });
-        const previousHash = sessionPrompt?.systemPromptHash ?? null;
+        const previousHash = sessionPromptHash ?? lastRecordedPromptHash();
         const changed = agentRuntime.agent.state.systemPrompt !== result.systemPrompt;
         if (changed) {
           agentRuntime.agent.state.systemPrompt = result.systemPrompt;
           pendingPromptLogEntry = {
+            version: PROMPT_MANIFEST_VERSION,
             at: (/* @__PURE__ */ new Date()).toISOString(),
             previousHash,
             systemPromptHash: result.systemPromptHash,
             tokenEstimate: result.tokenEstimate,
             thinkingLevel: agentRuntime.agent.state.thinkingLevel ?? null,
+            contextWindow,
+            contextWindowSource,
             projectPreload: result.projectPreload ?? null,
             sections: result.sections.map((s) => ({ id: s.id, tokenEstimate: s.tokenEstimate })),
             fragments: result.fragmentManifest.map((f) => ({
@@ -12991,6 +13478,7 @@ function createTurnContext(deps) {
         }
         lastSystemPromptReused = !changed;
         sessionPrompt = result;
+        sessionPromptHash = result.systemPromptHash;
         sessionPromptKey = key;
         return result;
       } catch (err) {
@@ -13022,6 +13510,9 @@ function createTurnContext(deps) {
             tokenEstimate: entry.tokenEstimate
           }
         });
+        if (entry.previousHash !== null && entry.previousHash !== entry.systemPromptHash) {
+          noteColdReason("prompt_recompiled");
+        }
       } catch {
       }
       appendPromptCompileRecord(currentMeta, entry);
@@ -13092,7 +13583,8 @@ function createTurnContext(deps) {
           toolCount: liveToolCount,
           compactionThreshold,
           compactionAuto,
-          promptCache: lastPromptCache
+          promptCache: lastPromptCache,
+          prewarm: lastPrewarm
         });
       }
       const streamingOutput = liveStreamingOutputTokens();
@@ -13122,7 +13614,8 @@ function createTurnContext(deps) {
         liveTotalTokens: totalUsed > 0 ? totalUsed : null,
         measured,
         lastCompaction: lastCompactionEvent,
-        promptCache: lastPromptCache
+        promptCache: lastPromptCache,
+        prewarm: lastPrewarm
       });
     },
     emitContextWindowWarningTransition(warning) {
@@ -13130,6 +13623,7 @@ function createTurnContext(deps) {
       lastContextWindowWarning = warning;
       deps.bus?.emit(BusChannels.ContextWarning, { warning });
     },
+    noteColdReason,
     consumeExpectedColdReasons(runtimeId) {
       runExpectedColdReasons = [];
       nextAssistantColdReasons = [];
@@ -13143,7 +13637,7 @@ function createTurnContext(deps) {
         }
       }
     },
-    promptCachePayloadForAssistant(usage) {
+    promptCachePayloadForAssistant(usage, backend) {
       const input = typeof usage.input === "number" ? usage.input : 0;
       const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
       const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0;
@@ -13151,34 +13645,54 @@ function createTurnContext(deps) {
         input,
         cacheRead,
         cacheWrite,
-        backendVerdict: backendCacheVerdict(input, cacheRead)
+        backendVerdict: backendCacheVerdict(input, cacheRead, backend)
       };
+      if (backend !== void 0) promptCache.backend = { ...backend };
       if (nextAssistantColdReasons.length > 0) {
         promptCache.expectedColdReasons = [...nextAssistantColdReasons];
         nextAssistantColdReasons = [];
       }
       return promptCache;
     },
+    notePrewarm(prewarm) {
+      lastPrewarm = prewarm;
+    },
     noteRunCacheSummary(messages, runFirstCallVerdict) {
+      lastPrewarm = null;
       const cacheSummary = sumRunUsage(messages);
       if (cacheSummary.hadUsage) {
+        let lastBackend = null;
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+          const message = messages[index];
+          if (message?.role !== "assistant") continue;
+          lastBackend = message.backendTimings ?? null;
+          break;
+        }
         lastPromptCache = {
           shellReused: lastSystemPromptReused,
           cacheReadTokens: cacheSummary.cacheRead > 0 || cacheSummary.cacheWrite > 0 ? cacheSummary.cacheRead : null,
           cacheWriteTokens: cacheSummary.cacheRead > 0 || cacheSummary.cacheWrite > 0 ? cacheSummary.cacheWrite : null,
           uncachedInputTokens: cacheSummary.input,
+          backend: lastBackend,
+          uncachedPrefillTokens: uncachedPrefillTokens(lastBackend),
           backendVerdict: runFirstCallVerdict,
           ...runExpectedColdReasons.length > 0 ? { expectedColdReasons: [...runExpectedColdReasons] } : {}
         };
       }
     },
     resetForSession() {
+      if (sessionPromptHash !== null) noteColdReason("prompt_recompiled");
       lastPromptCache = null;
+      lastPrewarm = null;
       lastSystemPromptReused = false;
+      sessionPromptHash = null;
       sessionPromptKey = null;
+      resumedPromptHashRead = false;
+      resumedPromptHash = null;
       sessionWorkingContextPaths.clear();
       pendingPromptLogEntry = null;
       emptyAutoCompactTurnId = null;
+      reconciledAnchor = null;
       const session = deps.session?.current();
       currentContextSnapshot = session ? getLatestContextSnapshot(session) : null;
     },
@@ -13475,7 +13989,8 @@ function createTurnPersistence(deps) {
     if (timing) payload.timing = timing;
     const usage = message.usage;
     if (usage && typeof usage === "object") {
-      payload.promptCache = deps.promptCachePayloadForAssistant(usage);
+      const backendTimings = message.backendTimings;
+      payload.promptCache = deps.promptCachePayloadForAssistant(usage, backendTimings);
     }
     const interruptedUsage = estimatedUsageForInterruptedTurn(message, deps.promptSideTokens());
     if (interruptedUsage !== null) payload.usage = interruptedUsage;
@@ -13516,8 +14031,8 @@ function createTurnPersistence(deps) {
     appendAssistantTurn,
     appendQueuedUserTurn(message) {
       if (message?.role !== "user") return;
-      const text = extractUserText(message).trim();
-      if (text.length === 0) return;
+      const text = extractUserText(message);
+      if (text.trim().length === 0) return;
       if (deps.consumePersistedEcho(text)) return;
       deps.removeQueuedMirrorEntry(text);
       if (!deps.session) return;
@@ -13678,6 +14193,266 @@ function createTurnPersistence(deps) {
   };
 }
 
+// src/interactive/turn-prewarm.ts
+init_esm_shims();
+
+// src/interactive/prewarm.ts
+init_esm_shims();
+var PREWARM_USER_TEXT = ".";
+var PREWARM_MAX_TOKENS = 1;
+var LLM_MESSAGE_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "toolResult"]);
+function prewarmPrefix(state) {
+  return {
+    systemPrompt: state.systemPrompt,
+    messages: state.messages.filter((message) => LLM_MESSAGE_ROLES.has(message.role ?? "")),
+    tools: [...state.tools]
+  };
+}
+function usageOf(message) {
+  if (message === null || typeof message !== "object") return null;
+  const usage = message.usage;
+  return usage !== null && typeof usage === "object" ? usage : null;
+}
+function backendOf(message) {
+  if (message === null || typeof message !== "object") return null;
+  const backend = message.backendTimings;
+  return backend !== null && typeof backend === "object" ? backend : null;
+}
+function prewarmPromptTokens(result) {
+  if (result.backend) return result.backend.promptTokens;
+  const usage = result.usage;
+  if (!usage) return null;
+  const total = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
+  return total > 0 ? total : null;
+}
+async function runPrewarmRound(input) {
+  const prefix = prewarmPrefix(input.state);
+  const context = {
+    systemPrompt: prefix.systemPrompt,
+    messages: [
+      ...prefix.messages,
+      { role: "user", content: [{ type: "text", text: PREWARM_USER_TEXT }], timestamp: Date.now() }
+    ],
+    tools: prefix.tools
+  };
+  const options = { maxTokens: PREWARM_MAX_TOKENS };
+  if (input.state.thinkingLevel !== "off") options.reasoning = input.state.thinkingLevel;
+  if (input.apiKey !== void 0) options.apiKey = input.apiKey;
+  if (input.signal !== void 0) options.signal = input.signal;
+  const send = input.streamFn ?? streamSimple;
+  const startedAt = performance.now();
+  let firstDeltaAt = null;
+  const elapsed = () => Math.round(Math.max(0, performance.now() - startedAt));
+  const ttft = () => firstDeltaAt === null ? null : Math.round(Math.max(0, firstDeltaAt - startedAt));
+  try {
+    const events = send(
+      input.model,
+      context,
+      options
+    );
+    for await (const event of events) {
+      if (firstDeltaAt === null && event.type !== "start") firstDeltaAt = performance.now();
+      if (event.type === "done") {
+        return {
+          aborted: false,
+          usage: usageOf(event.message),
+          backend: backendOf(event.message),
+          timing: { ttftMs: ttft(), apiMs: elapsed() },
+          errorMessage: null
+        };
+      }
+      if (event.type === "error") {
+        const failed = event.error;
+        const aborted = event.reason === "aborted" || failed.stopReason === "aborted" || input.signal?.aborted === true;
+        return {
+          aborted,
+          usage: usageOf(event.error),
+          backend: backendOf(event.error),
+          timing: { ttftMs: ttft(), apiMs: elapsed() },
+          errorMessage: aborted ? null : typeof failed.errorMessage === "string" ? failed.errorMessage : "pre-warm failed"
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      aborted: input.signal?.aborted === true,
+      usage: null,
+      backend: null,
+      timing: { ttftMs: ttft(), apiMs: elapsed() },
+      errorMessage: input.signal?.aborted === true ? null : error instanceof Error ? error.message : String(error)
+    };
+  }
+  return {
+    aborted: input.signal?.aborted === true,
+    usage: null,
+    backend: null,
+    timing: { ttftMs: ttft(), apiMs: elapsed() },
+    errorMessage: null
+  };
+}
+
+// src/interactive/turn-prewarm.ts
+var ABORT_ROUND_ON_SUBMIT = false;
+function createTurnPrewarm(deps) {
+  const round = deps.runPrewarm ?? runPrewarmRound;
+  const abortOnSubmit = deps.abortRoundOnSubmit ?? ABORT_ROUND_ON_SUBMIT;
+  let pendingTrigger = null;
+  let timer = null;
+  let active = null;
+  const detached = /* @__PURE__ */ new WeakSet();
+  let inFlight = Promise.resolve(null);
+  let dispatchesInFlight = 0;
+  const unsubscribeDispatch = [
+    deps.bus?.on(BusChannels.DispatchStarted, () => {
+      dispatchesInFlight += 1;
+    }) ?? null,
+    ...[BusChannels.DispatchCompleted, BusChannels.DispatchFailed].map(
+      (channel) => deps.bus?.on(channel, () => {
+        dispatchesInFlight = Math.max(0, dispatchesInFlight - 1);
+      }) ?? null
+    )
+  ];
+  const dispatchActive = () => dispatchesInFlight > 0 || deps.hasActiveDispatch();
+  const admissionRefusal = () => {
+    if (deps.getSettings().prewarm?.enabled === false) return "disabled";
+    if (!deps.isLatencySurface()) return "surface";
+    if (deps.state.streaming || deps.isTurnActive()) return "turn-active";
+    if (dispatchActive()) return "dispatch-active";
+    const targetId = deps.getSettings().orchestrator?.target?.trim();
+    const runtimeId = targetId ? deps.providers.getTarget(targetId)?.runtime : void 0;
+    if (runtimeId === void 0 || deps.providers.getRuntime(runtimeId)?.tier !== "local-native") return "tier";
+    return null;
+  };
+  const runOnce = async (trigger, controller) => {
+    const refusal2 = admissionRefusal();
+    if (refusal2) return { ran: false, reason: refusal2 };
+    const prepared = await deps.prepareRuntime(controller.signal);
+    if (!prepared.ok) return { ran: false, reason: "unresolved" };
+    const runtime = prepared.runtime;
+    if (deps.providers.getRuntime(runtime.runtimeId)?.tier !== "local-native") {
+      return { ran: false, reason: "tier" };
+    }
+    deps.applySessionTools(runtime);
+    await deps.context.ensureSessionPrompt(runtime);
+    const lateRefusal = admissionRefusal();
+    if (lateRefusal) return { ran: false, reason: lateRefusal };
+    if (detached.has(controller) || controller.signal.aborted) return { ran: false, reason: "superseded" };
+    const releaseEndpointSlot = deps.registerEndpointSlot?.(runtime) ?? null;
+    let result;
+    try {
+      result = await round({
+        model: runtime.agent.state.model,
+        state: {
+          systemPrompt: runtime.agent.state.systemPrompt,
+          messages: runtime.agent.state.messages,
+          tools: runtime.agent.state.tools,
+          thinkingLevel: runtime.agent.state.thinkingLevel ?? "off"
+        },
+        ...prepared.apiKey !== void 0 ? { apiKey: prepared.apiKey } : {},
+        signal: controller.signal
+      });
+    } finally {
+      releaseEndpointSlot?.();
+    }
+    const wasDetached = detached.has(controller) || controller.signal.aborted;
+    const promptTokens = prewarmPromptTokens(result);
+    if (!wasDetached) {
+      deps.context.notePrewarm({
+        tokens: promptTokens,
+        ms: result.timing.apiMs,
+        aborted: result.aborted
+      });
+    }
+    deps.recordUsage(runtime, result.usage);
+    try {
+      deps.session?.appendEntry({
+        kind: "custom",
+        customType: "prewarm",
+        // Never a model message and never a rendered transcript block: a
+        // pre-warm is a fact about the backend, not something the session said.
+        display: false,
+        parentTurnId: deps.state.lastTurnId,
+        data: {
+          trigger,
+          target: runtime.targetId,
+          model: runtime.wireModelId,
+          promptTokens,
+          aborted: result.aborted,
+          detached: wasDetached,
+          timing: result.timing,
+          promptCache: {
+            input: result.usage?.input ?? 0,
+            cacheRead: result.usage?.cacheRead ?? 0,
+            cacheWrite: result.usage?.cacheWrite ?? 0,
+            ...result.backend ? { backend: { ...result.backend } } : {}
+          },
+          ...result.errorMessage ? { error: result.errorMessage } : {}
+        }
+      });
+    } catch {
+    }
+    return { ran: true, trigger };
+  };
+  const releaseActiveRound = () => {
+    const controller = active;
+    if (controller === null) return;
+    detached.add(controller);
+    if (abortOnSubmit) controller.abort();
+    active = null;
+  };
+  const fire = () => {
+    timer = null;
+    const trigger = pendingTrigger;
+    pendingTrigger = null;
+    if (trigger === null) return;
+    const controller = new AbortController();
+    active = controller;
+    const previous = inFlight;
+    inFlight = previous.catch(() => null).then(() => runOnce(trigger, controller)).catch(() => null).finally(() => {
+      if (active === controller) active = null;
+    });
+  };
+  return {
+    schedule(trigger) {
+      releaseActiveRound();
+      pendingTrigger = trigger;
+      if (timer !== null) return;
+      timer = setTimeout(fire, 0);
+    },
+    cancel() {
+      pendingTrigger = null;
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      releaseActiveRound();
+    },
+    settled() {
+      return new Promise((resolve7) => {
+        setTimeout(() => {
+          resolve7(inFlight.catch(() => null));
+        }, 0);
+      });
+    },
+    dispose() {
+      for (const unsubscribe of unsubscribeDispatch) unsubscribe?.();
+      pendingTrigger = null;
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      active?.abort();
+      active = null;
+    }
+  };
+}
+function subscribePrewarmToCompaction(bus, prewarm) {
+  const unsubscribe = bus?.on(BusChannels.CompactionEnd, () => {
+    prewarm.schedule("compaction");
+  });
+  return () => unsubscribe?.();
+}
+
 // src/interactive/turn-queues.ts
 init_esm_shims();
 var DEFAULT_STEERING_MODE = "next-slot";
@@ -13689,14 +14464,13 @@ function createTurnQueues(deps) {
     deps.emitQueueUpdateEvent(queuedMirror.map((entry) => ({ ...entry })));
   };
   const enqueue = (text, kind) => {
-    const trimmed = text.trim();
-    if (trimmed.length === 0 || !state.streaming || !state.runtime) return false;
+    if (text.trim().length === 0 || !state.streaming || !state.runtime) return false;
     const message = {
       role: "user",
-      content: trimmed,
+      content: text,
       timestamp: Date.now()
     };
-    queuedMirror.push({ text: trimmed, kind });
+    queuedMirror.push({ text, kind });
     if (kind === "steer") {
       state.runtime.agent.steer(message);
     } else {
@@ -14090,7 +14864,11 @@ function createTurnRuntime(deps) {
       requestedThinkingLevel: settings.orchestrator.thinkingLevel ?? "off",
       use: "orchestrator",
       requireTools: false,
-      requireOutputBudget: true
+      requireOutputBudget: true,
+      // A resumed session already knows what this backend had open; without
+      // it the first turn budgets against the probed server-wide figure and
+      // corrects only once discovery reports a loaded window (issue #227).
+      knownLoadedContextWindow: context.rememberedLoadedContextWindow(targetId, wireModelId)
     });
     if (!resolved.ok) {
       const failure = resolved.diagnostics.find((entry) => entry.severity === "error") ?? resolved.diagnostics[0];
@@ -14180,7 +14958,8 @@ function createTurnRuntime(deps) {
           requestedThinkingLevel: deps.getSettings().orchestrator.thinkingLevel ?? "off",
           use: "orchestrator",
           requireTools: false,
-          requireOutputBudget: true
+          requireOutputBudget: true,
+          knownLoadedContextWindow: context.rememberedLoadedContextWindow(target.target.id, target.wireModelId)
         });
         if (!refreshed.ok) return;
         const liveModel = state.runtime.agent.state.model;
@@ -14541,7 +15320,8 @@ function createTurnRuntime(deps) {
         if (isAssistant && usage && typeof usage === "object" && runFirstCallVerdict === null) {
           const input = typeof usage.input === "number" ? usage.input : 0;
           const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
-          runFirstCallVerdict = backendCacheVerdict(input, cacheRead);
+          const backendTimings = enrichedEvent.message.backendTimings;
+          runFirstCallVerdict = backendCacheVerdict(input, cacheRead, backendTimings);
         }
         if (usage) {
           context.reconcileUsage(usage);
@@ -14585,6 +15365,8 @@ function createTurnState(initialThinkingLevel) {
     runtime: null,
     lastTurnId: null,
     streaming: false,
+    turnPreparation: "idle",
+    turnPreparationSince: 0,
     currentThinkingLevel: initialThinkingLevel,
     replayedContextMessages: [],
     activeUserTurnId: null,
@@ -14702,6 +15484,31 @@ function createChatLoop(deps) {
   const middlewareToolChoice = deps.middlewareToolChoice ?? createMiddlewareToolChoiceControl();
   const state = createTurnState(deps.getSettings().orchestrator.thinkingLevel ?? "off");
   const toolStartTimes = /* @__PURE__ */ new Map();
+  const preparationListeners = /* @__PURE__ */ new Set();
+  const setTurnPreparation = (phase) => {
+    if (state.turnPreparation === phase) return;
+    if (state.turnPreparation === "idle") state.turnPreparationSince = Date.now();
+    if (phase === "idle") state.turnPreparationSince = 0;
+    state.turnPreparation = phase;
+    for (const listener of preparationListeners) {
+      try {
+        listener(phase);
+      } catch {
+      }
+    }
+  };
+  let preparingSubmits = 0;
+  const enterPreparation = () => {
+    preparingSubmits += 1;
+    if (state.turnPreparation === "idle") setTurnPreparation("preparing");
+  };
+  const leavePreparation = () => {
+    preparingSubmits = Math.max(0, preparingSubmits - 1);
+    if (preparingSubmits === 0) setTurnPreparation("idle");
+  };
+  const endPreparationCompaction = () => {
+    setTurnPreparation(preparingSubmits > 0 ? "preparing" : "idle");
+  };
   const emit = (event) => {
     for (const listener of listeners) {
       listener(event);
@@ -14778,7 +15585,7 @@ function createChatLoop(deps) {
     middlewareToolChoice,
     consumePersistedEcho: (text) => queues.consumePersistedEcho(text),
     removeQueuedMirrorEntry: (text) => queues.removeQueuedMirrorEntry(text),
-    promptCachePayloadForAssistant: (usage) => context.promptCachePayloadForAssistant(usage),
+    promptCachePayloadForAssistant: (usage, backend) => context.promptCachePayloadForAssistant(usage, backend),
     promptSideTokens: () => context.promptSideTokens(),
     observability: deps.observability
   });
@@ -14849,6 +15656,16 @@ function createChatLoop(deps) {
       return { ok: false, reason: err instanceof Error ? err.message : String(err) };
     }
   };
+  const withEndpointSlot = async (runtime, round) => {
+    const endpointKey = canonicalEndpointKey(runtime.runtimeResolution.target);
+    const release = endpointKey === null ? () => {
+    } : registerForegroundStream(endpointKey);
+    try {
+      return await round();
+    } finally {
+      release();
+    }
+  };
   const writeOutOfTurnUsageRow = deps.recordOutOfTurnUsageRow ?? ((row2) => appendOutOfTurnUsageRow(clioStateDir(), row2));
   const recordOutOfTurnUsage = (runtime, usage, label) => {
     if (!usage) return;
@@ -14893,6 +15710,39 @@ function createChatLoop(deps) {
       }
     });
   };
+  let turnActive = false;
+  const prewarm = createTurnPrewarm({
+    state,
+    getSettings: deps.getSettings,
+    providers: deps.providers,
+    context,
+    bus: deps.bus,
+    ...deps.session ? { session: deps.session } : {},
+    isLatencySurface: () => deps.isLatencySurface?.() !== false,
+    isTurnActive: () => turnActive,
+    hasActiveDispatch: () => (deps.hasActiveDispatch ?? deps.hasAttachedDispatch)?.() === true,
+    prepareRuntime: async (signal) => {
+      await turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {
+      });
+      return prepareOutOfTurnRound("a turn is in flight", signal);
+    },
+    applySessionTools: (runtime) => {
+      runtime.agent.state.tools = resolveSessionTools(
+        runtime,
+        deps.toolRegistry,
+        currentToolInvokeOptions,
+        turnRuntime.toolTelemetry
+      );
+    },
+    recordUsage: (runtime, usage) => {
+      recordOutOfTurnUsage(runtime, sideQuestionUsage(usage), "prewarm");
+    },
+    ...deps.runPrewarm ? { runPrewarm: deps.runPrewarm } : {},
+    ...deps.abortPrewarmOnSubmit === void 0 ? {} : { abortRoundOnSubmit: deps.abortPrewarmOnSubmit },
+    ...deps.registerPrewarmEndpointSlot ? { registerEndpointSlot: deps.registerPrewarmEndpointSlot } : {}
+  });
+  const unsubscribePrewarmCompaction = subscribePrewarmToCompaction(deps.bus, prewarm);
+  prewarm.schedule("session-start");
   const api = {
     steer: (text) => queues.steer(text),
     queueFollowUp: (text) => queues.queueFollowUp(text),
@@ -14905,9 +15755,9 @@ function createChatLoop(deps) {
         let mode = options.steering ?? DEFAULT_STEERING_MODE;
         const trimmed = text.trim();
         if (mode === "interrupt" && trimmed.length > 0) {
-          const refusal = interruptRefusalReason();
-          if (refusal !== null) {
-            emitNotice(`[Clio Coder] interrupt refused: ${refusal}. Queued for the next slot instead.`, "warning");
+          const refusal2 = interruptRefusalReason();
+          if (refusal2 !== null) {
+            emitNotice(`[Clio Coder] interrupt refused: ${refusal2}. Queued for the next slot instead.`, "warning");
             mode = "next-slot";
           } else {
             const prior = priorSubmit;
@@ -14931,15 +15781,15 @@ function createChatLoop(deps) {
           const hasImages = options.images !== void 0 && options.images.length > 0;
           if (!hasImages && trimmed.length > 0 && state.runtime) {
             if (isWorkerShareNote(trimmed)) state.turnSharedWorkerNote = true;
-            if (mode === "end-of-turn") queues.queueFollowUp(trimmed);
-            else queues.steer(trimmed);
+            if (mode === "end-of-turn") queues.queueFollowUp(text);
+            else queues.steer(text);
             return;
           }
           emitNotice("[Clio Coder] response already in progress. Press Esc to cancel the active run.");
           return;
         }
       }
-      state.lastRunSnapshot = null;
+      const previousRunSnapshot = state.lastRunSnapshot;
       let agentRuntime;
       try {
         await turnRuntime.ensureLiveCapabilitiesForSelectedModel();
@@ -14970,6 +15820,7 @@ function createChatLoop(deps) {
         currentToolInvokeOptions,
         turnRuntime.toolTelemetry
       );
+      const toolSignature = toolSignatureFromState(agentRuntime.agent.state.tools);
       const askUserPolicy = createAskUserToolPolicy(agentRuntime.agent.state.tools);
       middleware.fireTurnStart(agentRuntime, text, pendingSkillRequests.length, options.requestContinuation === true);
       const reminderBlock = middleware.flushPendingReminders();
@@ -14984,9 +15835,12 @@ function createChatLoop(deps) {
       const submittedText = [reminderBlock, skillPreamble, taskMemoryHandoffSource, text].filter((part) => part.length > 0).join("\n\n");
       const forceNow = process.env.CLIO_CODER_FORCE_COMPACT === "1";
       try {
+        setTurnPreparation("compacting");
         await context.runAutoCompact(agentRuntime, forceNow, void 0, void 0, submittedText);
       } catch (err) {
         emitNotice(`[Clio Coder] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        endPreparationCompaction();
       }
       const compiledPrompt = await context.ensureSessionPrompt(agentRuntime);
       const compactionThreshold = deps.getSettings().compaction?.threshold ?? null;
@@ -14995,18 +15849,23 @@ function createChatLoop(deps) {
         pendingUserInput: submittedText,
         images,
         promptHash: compiledPrompt?.systemPromptHash,
-        toolSignature: toolSignatureFromState(agentRuntime.agent.state.tools)
+        toolSignature
       });
       const reservedOutput = resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens);
       const effectiveWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
       const pendingInputTokens = ceilChars(submittedText.length);
       let turnSnapshot = captureTurnSnapshot("pending");
-      const totalEstimate = snapshotInputTokens(turnSnapshot) + pendingInputTokens + reservedOutput;
+      const budgetedPromptTokens = (snapshot) => Math.max(
+        snapshotInputTokens(snapshot) + pendingInputTokens,
+        context.liveContextEstimate(agentRuntime, submittedText).tokens
+      );
+      const totalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
       if (effectiveWindow > 0 && totalEstimate > effectiveWindow) {
         emitNotice(
-          `[Clio Coder] Estimated request size ${totalEstimate} tokens (input ${snapshotInputTokens(turnSnapshot) + pendingInputTokens} + output budget ${reservedOutput}) exceeds the effective context window of ${effectiveWindow} tokens. Running compaction before sending...`
+          `[Clio Coder] Estimated request size ${totalEstimate} tokens (input ${totalEstimate - reservedOutput} + output budget ${reservedOutput}) exceeds the effective context window of ${effectiveWindow} tokens. Running compaction before sending...`
         );
-        const compacted = await context.runAutoCompact(agentRuntime, true, void 0, void 0, submittedText);
+        setTurnPreparation("compacting");
+        const compacted = await context.runAutoCompact(agentRuntime, true, void 0, void 0, submittedText).finally(endPreparationCompaction);
         if (!compacted) {
           emitNotice(
             "[Clio Coder] Compaction could not reclaim enough space. Request blocked; trim the prompt, reduce active tools, or start a fresh session."
@@ -15015,7 +15874,7 @@ function createChatLoop(deps) {
         }
         context.refreshAgentMessagesFromSession(agentRuntime);
         turnSnapshot = captureTurnSnapshot("pending");
-        const postTotalEstimate = snapshotInputTokens(turnSnapshot) + pendingInputTokens + reservedOutput;
+        const postTotalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
         if (postTotalEstimate > effectiveWindow) {
           emitNotice(
             `[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`
@@ -15035,6 +15894,13 @@ function createChatLoop(deps) {
       );
       if (interrupted) emit({ type: "queued_user_turn", text, kind: "interrupt" });
       context.logPromptCompileIfPending();
+      const previousThinkingLevel = previousRunSnapshot?.runtimeResolution?.effectiveThinkingLevel;
+      if (previousThinkingLevel !== void 0 && previousThinkingLevel !== agentRuntime.runtimeResolution.effectiveThinkingLevel) {
+        context.noteColdReason("thinking_change");
+      }
+      if (typeof previousRunSnapshot?.toolSignature === "string" && previousRunSnapshot.toolSignature !== toolSignature) {
+        context.noteColdReason("tool_surface_change");
+      }
       turnSnapshot = { ...turnSnapshot, turnId: userTurnId ?? "unknown" };
       context.setCurrentSnapshot(turnSnapshot);
       context.persistContextSnapshot(turnSnapshot);
@@ -15049,7 +15915,7 @@ function createChatLoop(deps) {
         compiledPromptHash: promptHash,
         staticCompositionHash: promptHash,
         promptSignature: promptHash,
-        toolSignature: toolSignatureFromState(agentRuntime.agent.state.tools),
+        toolSignature,
         runtimeResolution: runtimeTargetSnapshot(agentRuntime.runtimeResolution),
         sessionId: deps.session?.current()?.id ?? null,
         cwd: process.cwd()
@@ -15062,6 +15928,9 @@ function createChatLoop(deps) {
       state.interruptedUsage = null;
       context.consumeExpectedColdReasons(agentRuntime.runtimeId);
       state.streaming = true;
+      const endpointKey = canonicalEndpointKey(agentRuntime.runtimeResolution.target);
+      const releaseForeground = endpointKey === null ? () => {
+      } : registerForegroundStream(endpointKey);
       try {
         options.onAdmitted?.();
       } catch {
@@ -15111,6 +15980,7 @@ function createChatLoop(deps) {
         }
         await recovery.runCompactAndRetry(agentRuntime, runtimePromptText, overflow, images);
       } finally {
+        releaseForeground();
         if (askUserPolicy) {
           try {
             await finalizeAskUserInterviewForHost(
@@ -15180,9 +16050,19 @@ function createChatLoop(deps) {
     isStreaming() {
       return state.streaming;
     },
+    turnPreparation() {
+      return { phase: state.turnPreparation, since: state.turnPreparationSince };
+    },
+    onTurnPreparation(handler) {
+      preparationListeners.add(handler);
+      return () => {
+        preparationListeners.delete(handler);
+      };
+    },
     contextUsage: () => context.contextUsage(),
     contextLedger: () => context.contextLedger(),
     whenSettled: () => activeSubmit,
+    whenPrewarmSettled: () => prewarm.settled(),
     resetForSession(leafTurnId, replayMessages) {
       if (state.runtime) {
         state.runtime.agent.abort();
@@ -15194,6 +16074,7 @@ function createChatLoop(deps) {
       middleware.clearPendingReminders();
       middlewareToolChoice.reset();
       state.lastTurnId = leafTurnId;
+      state.lastRunSnapshot = null;
       context.resetForSession();
       void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {
       });
@@ -15204,10 +16085,13 @@ function createChatLoop(deps) {
       if (deps.protectedArtifacts) {
         reloadProtectedArtifactsForSession(deps.protectedArtifacts, deps.readSessionEntries);
       }
+      prewarm.schedule(replayMessages && replayMessages.length > 0 ? "resume" : "session-start");
     },
     dispose() {
       unsubscribeConfigReload?.();
       unsubscribeSynthesisLock?.();
+      unsubscribePrewarmCompaction();
+      prewarm.dispose();
       context.dispose();
       if (state.runtime) {
         state.runtime.agent.abort();
@@ -15230,16 +16114,19 @@ function createChatLoop(deps) {
       if (!prepared.ok) return { status: "refused", reason: prepared.reason };
       let result;
       try {
-        result = await sideQuestionRound({
-          model: prepared.runtime.agent.state.model,
-          // Read-only: runSideQuestion copies before appending its own
-          // message, so the live agent's history is untouched.
-          messages: prepared.runtime.agent.state.messages,
-          question: text,
-          ...prepared.apiKey !== void 0 ? { apiKey: prepared.apiKey } : {},
-          ...options.signal ? { signal: options.signal } : {},
-          ...options.onDelta ? { onDelta: options.onDelta } : {}
-        });
+        result = await withEndpointSlot(
+          prepared.runtime,
+          () => sideQuestionRound({
+            model: prepared.runtime.agent.state.model,
+            // Read-only: runSideQuestion copies before appending its own
+            // message, so the live agent's history is untouched.
+            messages: prepared.runtime.agent.state.messages,
+            question: text,
+            ...prepared.apiKey !== void 0 ? { apiKey: prepared.apiKey } : {},
+            ...options.signal ? { signal: options.signal } : {},
+            ...options.onDelta ? { onDelta: options.onDelta } : {}
+          })
+        );
       } catch (err) {
         return { status: "failed", reason: err instanceof Error ? err.message : String(err) };
       }
@@ -15258,14 +16145,21 @@ function createChatLoop(deps) {
       if (!prepared.ok) return { status: "refused", reason: prepared.reason };
       let result;
       try {
-        result = await handoffRound({
-          model: prepared.runtime.agent.state.model,
-          // Read-only, exactly as the side-question round treats it.
-          messages: prepared.runtime.agent.state.messages,
-          goal: text,
-          ...prepared.apiKey !== void 0 ? { apiKey: prepared.apiKey } : {},
-          ...options.signal ? { signal: options.signal } : {}
-        });
+        result = await withEndpointSlot(
+          prepared.runtime,
+          () => handoffRound({
+            model: prepared.runtime.agent.state.model,
+            // Read-only, exactly as the side-question round treats it.
+            messages: prepared.runtime.agent.state.messages,
+            goal: text,
+            // The runtime id is what decides whether the schema can be bound
+            // on the wire rather than only stated in the prompt.
+            runtimeId: prepared.runtime.runtimeResolution.runtime.id,
+            ...prepared.apiKey !== void 0 ? { apiKey: prepared.apiKey } : {},
+            ...options.signal ? { signal: options.signal } : {},
+            ...options.repair ? { repair: options.repair } : {}
+          })
+        );
       } catch (err) {
         return { status: "failed", reason: err instanceof Error ? err.message : String(err) };
       }
@@ -15304,13 +16198,17 @@ function createChatLoop(deps) {
   const submitInner = api.submit.bind(api);
   const submitTracked = (text, options) => {
     priorSubmit = activeSubmit;
-    const run = submitInner(text, options);
+    turnActive = true;
+    const run = submitInner(text, options).finally(() => {
+      turnActive = false;
+    });
     activeSubmit = run.catch(() => {
     });
     return run;
   };
   let admissionTail = null;
   api.submit = (text, options = {}) => {
+    prewarm.cancel();
     const previous = admissionTail;
     let release = () => {
     };
@@ -15322,14 +16220,30 @@ function createChatLoop(deps) {
       release();
       if (admissionTail === ticket) admissionTail = null;
     };
-    const start = () => submitTracked(text, {
-      ...options,
-      onAdmitted: () => {
-        releaseTicket();
-        options.onAdmitted?.();
+    enterPreparation();
+    let leftPreparation = false;
+    const leaveOnce = () => {
+      if (leftPreparation) return;
+      leftPreparation = true;
+      leavePreparation();
+    };
+    const start = async () => {
+      const { onPreparationVisible, ...submitOptions } = options;
+      try {
+        await onPreparationVisible?.();
+      } catch {
       }
-    }).finally(releaseTicket);
-    return previous ? previous.then(start) : start();
+      return submitTracked(text, {
+        ...submitOptions,
+        onAdmitted: () => {
+          releaseTicket();
+          leaveOnce();
+          options.onAdmitted?.();
+        }
+      }).finally(releaseTicket);
+    };
+    const run = previous ? previous.then(start) : start();
+    return run.finally(leaveOnce);
   };
   return api;
 }
@@ -15632,6 +16546,7 @@ function verificationText(state) {
   if (!state || state.status === "idle") return "";
   if (state.status === "running") return `${GLYPH.running} verify running`;
   if (state.status === "ok") return `${GLYPH.ok} verify ok ${state.detail}`;
+  if (state.status === "retired") return `${GLYPH.warn} verify retired ${state.detail}`;
   return `${GLYPH.error} verify fail ${state.detail}`;
 }
 function buildArtifactHeader(artifact, verification, width) {
@@ -15643,11 +16558,22 @@ function buildArtifactHeader(artifact, verification, width) {
   if (size.length > 0) parts.push(theme6.fg("dim", size));
   const verify = verificationText(verification);
   if (verify.length > 0) {
-    const token = verification?.status === "ok" ? "success" : verification?.status === "fail" ? "error" : "info";
+    const token = verification?.status === "ok" ? "success" : verification?.status === "fail" ? "error" : verification?.status === "retired" ? "warning" : "info";
     parts.push(theme6.fg(token, verify));
   }
   return padAnsi(parts.join("  "), width, ELLIPSIS);
 }
+function buildArtifactHeaderLines(artifact, verification, width) {
+  const metadata = buildArtifactHeader(artifact, void 0, width);
+  const verify = verificationText(verification);
+  if (artifact === void 0 || verify.length === 0) return [metadata];
+  const theme6 = clioTheme();
+  const token = verification?.status === "ok" ? "success" : verification?.status === "fail" ? "error" : verification?.status === "retired" ? "warning" : "info";
+  return [
+    metadata,
+    ...wrapTextWithAnsi(theme6.fg(token, verify), Math.max(1, width)).map((line) => padAnsi(line, width, ELLIPSIS))
+  ];
+}
 function viewFooterHint(focus, canVerify, innerWidth) {
   if (innerWidth !== void 0 && viewUsesSinglePane(innerWidth - 2)) {
     const budget = innerWidth - 3;
@@ -15837,14 +16763,14 @@ var ViewOverlayView = class {
     this.ensureContentLoaded(artifact);
     this.lastContentWidth = width;
     const verification = artifact ? this.verifications.get(artifactKey(artifact)) : void 0;
-    const header = buildArtifactHeader(artifact, verification, width);
-    const bodyHeight = Math.max(0, height - 1);
+    const header = buildArtifactHeaderLines(artifact, verification, width);
+    const bodyHeight = Math.max(0, height - header.length);
     this.lastContentBodyHeight = Math.max(1, bodyHeight);
     const body = this.renderedContentLines(width);
     const maxOffset = Math.max(0, body.length - Math.max(1, bodyHeight));
     if (this.contentScrollOffset > maxOffset) this.contentScrollOffset = maxOffset;
     const visible = body.slice(this.contentScrollOffset, this.contentScrollOffset + bodyHeight).map((line) => padAnsi(line, width, ELLIPSIS));
-    const lines = [header, ...visible];
+    const lines = [...header, ...visible];
     return this.fixedLines(lines, width, height);
   }
   fixedLines(lines, width, height) {
@@ -15957,7 +16883,7 @@ var ViewOverlayView = class {
     void artifact.verify().then((result) => {
       this.verifications.set(
         key,
-        result.ok ? { status: "ok", detail: result.detail } : { status: "fail", detail: result.detail }
+        result.ok ? { status: "ok", detail: result.detail } : { status: result.retired === true ? "retired" : "fail", detail: result.detail }
       );
     }).catch((err) => {
       const detail = err instanceof Error ? err.message : String(err);
@@ -16034,7 +16960,8 @@ function createQuestionState(question) {
     selected: /* @__PURE__ */ new Set(),
     customAnswer: "",
     inputValue: "",
-    answer: ""
+    answer: "",
+    rawValue: ""
   };
 }
 function isOtherOption(label) {
@@ -16071,12 +16998,16 @@ function optionIndexFromValue(value) {
   const index = Number(value.slice("option:".length));
   return Number.isInteger(index) && index >= 0 ? index : null;
 }
-function answerText(question, selected, customAnswer) {
-  const parts = [];
+function selectedOptionLabels(question, selected) {
+  const labels = [];
   for (const index of [...selected].sort((a, b) => a - b)) {
     const label = question.options?.[index]?.label;
-    if (label) parts.push(label);
+    if (label) labels.push(label);
   }
+  return labels;
+}
+function answerText(question, selected, customAnswer) {
+  const parts = selectedOptionLabels(question, selected);
   const custom = customAnswer.trim();
   if (custom.length > 0) parts.push(custom);
   return parts.join("; ");
@@ -16193,6 +17124,10 @@ var AskUserOverlayView = class {
       this.commitMultiSelectOrOpenOther(state);
       return;
     }
+    if (this.isAddTextKey(data)) {
+      this.chooseFocusedAndOpenText(question, state);
+      return;
+    }
     this.list?.handleInput(data);
   }
   /**
@@ -16319,20 +17254,16 @@ var AskUserOverlayView = class {
         { key: "Alt+Left/Right", verb: "question" }
       ]) : this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
     }
+    const addText = { key: "t", verb: "add text", short: "text" };
     if (question.multi_select === true) {
       return this.questions.length > 1 ? this.withScrollHint([
         { key: "Left/Right", verb: "question" },
         { key: "Space", verb: "toggle" },
+        addText,
         { key: "Enter", verb: recordAnswer }
-      ]) : this.withScrollHint([
-        { key: "Space", verb: "toggle" },
-        { key: "Enter", verb: recordAnswer }
-      ]);
+      ]) : this.withScrollHint([{ key: "Space", verb: "toggle" }, addText, { key: "Enter", verb: recordAnswer }]);
     }
-    return this.questions.length > 1 ? this.withScrollHint([
-      { key: "Left/Right", verb: "question" },
-      { key: "Enter", verb: recordAnswer }
-    ]) : this.withScrollHint([{ key: "Enter", verb: recordAnswer }]);
+    return this.questions.length > 1 ? this.withScrollHint([{ key: "Left/Right", verb: "question" }, addText, { key: "Enter", verb: recordAnswer }]) : this.withScrollHint([addText, { key: "Enter", verb: recordAnswer }]);
   }
   renderDecisionContext(width) {
     const theme6 = clioTheme();
@@ -16433,6 +17364,32 @@ var AskUserOverlayView = class {
   isTextModeNextKey(data) {
     return this.questions.length > 1 && (matchesKey(data, "alt+right") || matchesKey(data, "ctrl+right"));
   }
+  /**
+   * The key that adds typed text to the option under the cursor.
+   *
+   * Choosing an option used to be the whole answer, so a model that offered
+   * "Exact number - I'll type it" gave the operator a label and nowhere to put
+   * the number; the interview then spent two of its four rounds asking for the
+   * figures again (issue #228). The list itself only reads the arrows, Enter,
+   * and Esc, so a letter is free here.
+   */
+  isAddTextKey(data) {
+    return matchesKey(data, "t");
+  }
+  /**
+   * Take the focused option and open the text field for it, without committing.
+   * Submitting the text records the label and the text together.
+   */
+  chooseFocusedAndOpenText(question, state) {
+    const current = this.list?.getSelectedItem();
+    const optionIndex = current && current.value !== "other" ? optionIndexFromValue(current.value) : null;
+    if (optionIndex !== null) {
+      if (question.multi_select === true) state.selected.add(optionIndex);
+      else state.selected = /* @__PURE__ */ new Set([optionIndex]);
+      state.focusedValue = `option:${optionIndex}`;
+    }
+    this.openTextInput(state.selected.size > 0 ? "Add your answer to the chosen option" : "Other answer");
+  }
   /**
    * The row above the question, or nothing.
    *
@@ -16586,14 +17543,15 @@ var AskUserOverlayView = class {
         return;
       }
       state.inputValue = answer;
+      state.rawValue = value;
       if (questionHasOptions(question) && question.multi_select === true) {
         state.customAnswer = answer;
         this.commitCurrentAnswer();
-      } else {
-        state.customAnswer = questionHasOptions(question) ? answer : "";
-        state.answer = answer;
-        this.finishIfCompleteOrAdvance();
+        return;
       }
+      state.customAnswer = questionHasOptions(question) ? answer : "";
+      state.answer = questionHasOptions(question) ? answerText(question, state.selected, state.customAnswer) : answer;
+      this.finishIfCompleteOrAdvance();
     };
     activeInput.onEscape = () => this.cancel();
     this.input = activeInput;
@@ -16622,7 +17580,10 @@ var AskUserOverlayView = class {
         return;
       }
       state.selected = /* @__PURE__ */ new Set([optionIndex]);
-      state.answer = question.options?.[optionIndex]?.label ?? item.label;
+      state.customAnswer = "";
+      state.rawValue = "";
+      state.inputValue = "";
+      state.answer = answerText(question, state.selected, state.customAnswer) || item.label;
       state.focusedValue = item.value;
       this.status = "";
       this.finishIfCompleteOrAdvance();
@@ -16734,12 +17695,26 @@ var AskUserOverlayView = class {
   allAnswered() {
     return this.states.length > 0 && this.states.every((state) => state.answer.trim().length > 0);
   }
+  /**
+   * What the round captured, as three separable facts per question: the one-line
+   * answer, the labels chosen, and the text typed. A reader tells a label-only
+   * answer from a label-plus-value one by whether `value` is there, which the
+   * joined string alone could never say.
+   */
   answers() {
     const answers = [];
     for (let index = 0; index < this.questions.length; index += 1) {
       const question = this.questions[index];
-      const answer = this.states[index]?.answer.trim();
-      if (question && answer && answer.length > 0) answers.push({ question: question.question, answer });
+      const state = this.states[index];
+      const answer = state?.answer.trim();
+      if (!question || !state || !answer || answer.length === 0) continue;
+      const options = selectedOptionLabels(question, state.selected);
+      answers.push({
+        question: question.question,
+        answer,
+        ...options.length > 0 ? { options } : {},
+        ...state.rawValue.length > 0 ? { value: state.rawValue } : {}
+      });
     }
     return answers;
   }
@@ -17348,7 +18323,7 @@ function legendRow2(group, contentWidth) {
   const tokens = formatTokens(group.tokens);
   const percent = formatContextPercent(group.percent);
   const right = `${tokens.padStart(9)}  ${percent.padStart(6)}`;
-  const labelToken = group.category === "free" || group.category === "reserve" ? "dim" : "muted";
+  const labelToken = group.category === "reserve" ? "frame" : group.category === "free" ? "dim" : "muted";
   const leftWidth = Math.max(0, contentWidth - visibleWidth(right) - 2);
   const labelText = group.label.length > leftWidth ? group.label.slice(0, leftWidth) : group.label.padEnd(leftWidth);
   return `${swatch} ${theme6.fg(labelToken, labelText)} ${theme6.fg("muted", right)}`;
@@ -17370,6 +18345,16 @@ function coldReasonLabel(reason) {
       return "compaction";
     case "dispatch":
       return "dispatch traffic";
+    case "residency":
+      return "residency change";
+    case "thinking_change":
+      return "thinking-level change";
+    case "tool_surface_change":
+      return "tool-surface change";
+    case "prompt_recompiled":
+      return "prompt recompile";
+    case "background_memory":
+      return "background memory step";
     default:
       return reason;
   }
@@ -17441,18 +18426,28 @@ function renderContextLedgerLines(ledger, contentWidth, workingSet, workingSetCo
   if (ledger.promptCache) {
     const cache2 = ledger.promptCache;
     const shell = cache2.shellReused ? "shell reused" : "shell recompiled";
-    const backend = cache2.backendVerdict === "hot" || cache2.backendVerdict === "partial" ? "backend reused" : cache2.backendVerdict === "cold" ? "backend cold" : cache2.backendVerdict === "small" ? "backend small" : "backend n/a";
+    const backendCacheReadsUnknown = cache2.backend?.cachedTokens === null;
+    const backend = backendCacheReadsUnknown ? "server does not report cache reads" : cache2.backendVerdict === "hot" || cache2.backendVerdict === "partial" ? "backend reused" : cache2.backendVerdict === "cold" ? "backend cold" : cache2.backendVerdict === "small" ? "backend small" : "backend n/a";
     const read = cache2.cacheReadTokens !== null ? `cache read ${formatTokens(cache2.cacheReadTokens)}` : "cache read n/a";
     const uncached = cache2.uncachedInputTokens !== null ? `uncached input ${formatTokens(cache2.uncachedInputTokens)}` : null;
-    const line = ["prompt cache:", shell, "\xB7", backend, "\xB7", read, ...uncached ? ["\xB7", uncached] : []].join(" ");
-    const coldReasons = cache2.backendVerdict === "cold" ? cache2.expectedColdReasons ?? [] : [];
-    const misleading = cache2.shellReused && cache2.backendVerdict === "cold" && coldReasons.length === 0;
+    const line = backendCacheReadsUnknown ? ["prompt cache:", shell, "\xB7", backend].join(" ") : ["prompt cache:", shell, "\xB7", backend, "\xB7", read, ...uncached ? ["\xB7", uncached] : []].join(" ");
+    const coldReasons = cache2.backendVerdict === "cold" && !backendCacheReadsUnknown ? cache2.expectedColdReasons ?? [] : [];
+    const misleading = cache2.shellReused && cache2.backendVerdict === "cold" && !backendCacheReadsUnknown && coldReasons.length === 0;
     lines.push(theme6.fg(misleading ? "warning" : "dim", line));
+    if (cache2.backend) {
+      const prefill = cache2.backend.cachedTokens !== null && cache2.uncachedPrefillTokens !== null ? `prefill: ${formatTokens(cache2.uncachedPrefillTokens)} uncached \xB7 ${formatTokens(cache2.backend.cachedTokens)} cached \xB7 ${formatTokens(cache2.backend.promptMs)} ms` : `prefill: ${formatTokens(cache2.backend.promptTokens)} prompt \xB7 ${formatTokens(cache2.backend.promptMs)} ms`;
+      lines.push(theme6.fg("dim", prefill));
+    }
     if (coldReasons.length > 0) {
       const reasons = coldReasons.map(coldReasonLabel).join(", ");
       lines.push(theme6.fg("dim", `last cold turn: ${reasons} (expected)`));
     }
   }
+  if (ledger.prewarm) {
+    const tokens = ledger.prewarm.tokens !== null ? `${formatTokens(ledger.prewarm.tokens)} tokens` : "prefix";
+    const aborted = ledger.prewarm.aborted ? " (aborted on submit; prefix stays in the slot)" : "";
+    lines.push(theme6.fg("dim", `prewarmed: ${tokens} in ${formatTokens(ledger.prewarm.ms)} ms${aborted}`));
+  }
   if (ledger.lastCompaction) {
     const pruneInfo = `last compaction: reclaimed ${formatTokens(ledger.lastCompaction.tokensBefore)} -> ${formatTokens(ledger.lastCompaction.tokensAfter)} tokens (${ledger.lastCompaction.stage})`;
     lines.push(theme6.fg("dim", pruneInfo));
@@ -17546,6 +18541,8 @@ function aggregateCostEntries(entries) {
       existing.row.apiCalls += entry.apiCalls ?? 1;
       if (entry.label === "side-question") existing.row.sideQuestions += 1;
       if (entry.label === "handoff") existing.row.handoffs += 1;
+      if (entry.label === "prewarm") existing.row.prewarms += 1;
+      if (entry.label === "background-memory") existing.row.backgroundMemory += 1;
       for (const requestedModelId of entry.requestedModelIds) existing.requestedModelIds.add(requestedModelId);
       addResponseModelIdObservationCounts(
         existing.responseModelIdObservationCounts,
@@ -17567,7 +18564,9 @@ function aggregateCostEntries(entries) {
         reasoningTokens: entry.reasoningTokens,
         apiCalls: entry.apiCalls ?? 1,
         sideQuestions: entry.label === "side-question" ? 1 : 0,
-        handoffs: entry.label === "handoff" ? 1 : 0
+        handoffs: entry.label === "handoff" ? 1 : 0,
+        prewarms: entry.label === "prewarm" ? 1 : 0,
+        backgroundMemory: entry.label === "background-memory" ? 1 : 0
       },
       requestedModelIds: new Set(entry.requestedModelIds),
       responseModelIdObservationCounts: { ...entry.responseModelIdObservationCounts },
@@ -17599,7 +18598,9 @@ function sumRows(rows) {
       reasoningTokens: acc.reasoningTokens + row2.reasoningTokens,
       apiCalls: acc.apiCalls + row2.apiCalls,
       sideQuestions: acc.sideQuestions + row2.sideQuestions,
-      handoffs: acc.handoffs + row2.handoffs
+      handoffs: acc.handoffs + row2.handoffs,
+      prewarms: acc.prewarms + row2.prewarms,
+      backgroundMemory: acc.backgroundMemory + row2.backgroundMemory
     }),
     {
       runs: 0,
@@ -17611,7 +18612,9 @@ function sumRows(rows) {
       reasoningTokens: 0,
       apiCalls: 0,
       sideQuestions: 0,
-      handoffs: 0
+      handoffs: 0,
+      prewarms: 0,
+      backgroundMemory: 0
     }
   );
 }
@@ -17633,21 +18636,37 @@ function kvBlock(entries) {
     return annotation ? `${row2} ${theme6.fg("dim", annotation)}` : row2;
   });
 }
-function summaryBlock(totalCost, totalTokens, rows) {
+function summaryBlock(totalCost, totalTokens, rows, promptCache) {
   const totals = sumRows(rows);
   const resolvedTotal = totalTokens > 0 ? totalTokens : totals.tokens;
   const cost = formatCostAggregate(totalCost);
+  const cacheRows = promptCache !== null && hasPromptCacheTelemetry(promptCache) ? [
+    [
+      "uncached prefill",
+      promptCache.uncachedPrefillTokens === null ? "not reported" : formatTokens2(promptCache.uncachedPrefillTokens)
+    ],
+    [
+      "cache verdicts",
+      `hot ${promptCache.verdictCounts.hot} \xB7 partial ${promptCache.verdictCounts.partial} \xB7 cold ${promptCache.verdictCounts.cold} \xB7 small ${promptCache.verdictCounts.small}`
+    ]
+  ] : [];
   return kvBlock([
-    ["turns", formatTokens2(totals.runs - totals.sideQuestions - totals.handoffs)],
+    [
+      "turns",
+      formatTokens2(totals.runs - totals.sideQuestions - totals.handoffs - totals.prewarms - totals.backgroundMemory)
+    ],
     ["model calls", formatTokens2(totals.apiCalls)],
     ...totals.sideQuestions > 0 ? [["side questions", formatTokens2(totals.sideQuestions)]] : [],
     ...totals.handoffs > 0 ? [["handoffs", formatTokens2(totals.handoffs)]] : [],
+    ...totals.prewarms > 0 ? [["pre-warms", formatTokens2(totals.prewarms)]] : [],
+    ...totals.backgroundMemory > 0 ? [["memory steps", formatTokens2(totals.backgroundMemory)]] : [],
     ...cost === null ? [] : [["cost", cost]],
     ["input", formatTokens2(totals.input)],
     ["output", formatTokens2(totals.output)],
     ["reasoning", ...reasoningValue(totals.reasoningTokens)],
     ["cache read", ...cacheReadValue(totals.cacheRead, totals.apiCalls)],
     ["cache write", formatTokens2(totals.cacheWrite)],
+    ...cacheRows,
     ["processed", `${formatTokens2(resolvedTotal)} tokens`]
   ]);
 }
@@ -17656,10 +18675,12 @@ function modelBlock(row2) {
   return kvBlock([
     ["requested model ids", row2.requestedModelIds.join(", ")],
     ["response model id observation", responseModelIdObservationCountsLabel(row2.responseModelIdObservationCounts)],
-    ["turns", formatTokens2(row2.runs - row2.sideQuestions - row2.handoffs)],
+    ["turns", formatTokens2(row2.runs - row2.sideQuestions - row2.handoffs - row2.prewarms - row2.backgroundMemory)],
     ["model calls", formatTokens2(row2.apiCalls)],
     ...row2.sideQuestions > 0 ? [["side questions", formatTokens2(row2.sideQuestions)]] : [],
     ...row2.handoffs > 0 ? [["handoffs", formatTokens2(row2.handoffs)]] : [],
+    ...row2.prewarms > 0 ? [["pre-warms", formatTokens2(row2.prewarms)]] : [],
+    ...row2.backgroundMemory > 0 ? [["memory steps", formatTokens2(row2.backgroundMemory)]] : [],
     ...cost === null ? [] : [["cost", cost]],
     ["input", formatTokens2(row2.input)],
     ["output", formatTokens2(row2.output)],
@@ -17669,10 +18690,10 @@ function modelBlock(row2) {
     ["processed", `${formatTokens2(row2.tokens)} tokens`]
   ]);
 }
-function formatCostOverlayBodyLines(totalCost, totalTokens, rows, contentWidth) {
+function formatCostOverlayBodyLines(totalCost, totalTokens, rows, contentWidth, promptCache = null) {
   const theme6 = clioTheme();
   const lines = [];
-  for (const line of summaryBlock(totalCost, totalTokens, rows)) {
+  for (const line of summaryBlock(totalCost, totalTokens, rows, promptCache)) {
     lines.push(line);
   }
   lines.push(rule(theme6, contentWidth));
@@ -17689,7 +18710,7 @@ function formatCostOverlayBodyLines(totalCost, totalTokens, rows, contentWidth)
   }
   return lines;
 }
-function buildCostSnapshot(observability, sessionId, snapshot) {
+function buildCostSnapshot(observability, sessionId, snapshot, getSessionEntries) {
   const entries = observability.costEntries();
   const rows = aggregateCostEntries(entries);
   const totalTokens = rows.reduce((sum, r) => sum + r.tokens, 0);
@@ -17697,7 +18718,8 @@ function buildCostSnapshot(observability, sessionId, snapshot) {
     sessionId,
     totalCost: snapshot?.session.cost ?? observability.sessionCostSummary(),
     totalTokens,
-    rows
+    rows,
+    promptCache: getSessionEntries ? foldPromptCacheTelemetry(getSessionEntries()) : null
   };
 }
 var CostOverlayBody = class {
@@ -17708,7 +18730,13 @@ var CostOverlayBody = class {
   render(width) {
     const contentWidth = Math.max(1, Math.floor(width));
     const snapshot = this.getSnapshot();
-    return formatCostOverlayBodyLines(snapshot.totalCost, snapshot.totalTokens, snapshot.rows, contentWidth);
+    return formatCostOverlayBodyLines(
+      snapshot.totalCost,
+      snapshot.totalTokens,
+      snapshot.rows,
+      contentWidth,
+      snapshot.promptCache
+    );
   }
   invalidate() {
   }
@@ -17716,7 +18744,9 @@ var CostOverlayBody = class {
 function openCostOverlay(tui, observability, options) {
   const sessionId = options?.sessionId ?? null;
   let latest = observability.snapshot();
-  const body = new CostOverlayBody(() => buildCostSnapshot(observability, sessionId, latest));
+  const body = new CostOverlayBody(
+    () => buildCostSnapshot(observability, sessionId, latest, options?.getSessionEntries)
+  );
   const handle = showClioOverlayFrame(tui, body, {
     anchor: "center",
     width: COST_OVERLAY_WIDTH,
@@ -17803,6 +18833,38 @@ function compileFleetRunPreview(input) {
     diagnostics.push(describeError(error));
     return fail();
   }
+  const routes = /* @__PURE__ */ new Map();
+  if (input.resolveRoute !== void 0) {
+    for (const step of plan.steps) {
+      if (step.kind === "code") continue;
+      try {
+        const route = input.resolveRoute({
+          stepId: step.id,
+          agentId: step.agentId,
+          task: step.task,
+          scope: step.scope,
+          ...step.target !== void 0 ? { target: step.target } : {},
+          ...step.profile !== void 0 ? { profile: step.profile } : {}
+        });
+        if (route !== null) routes.set(step.id, route);
+      } catch (error) {
+        diagnostics.push(`step '${step.id}' route preflight failed: ${describeError(error)}`);
+      }
+    }
+    plan = bindExecutionPlanEndpoints(
+      plan,
+      Object.fromEntries(
+        [...routes].map(([stepId, route]) => [
+          stepId,
+          route.endpoint === void 0 ? void 0 : {
+            key: route.endpoint.key,
+            limit: route.endpoint.limit,
+            ...route.endpoint.foregroundHeld !== void 0 ? { foregroundHeld: route.endpoint.foregroundHeld } : {}
+          }
+        ])
+      )
+    );
+  }
   try {
     preflightWriteBoundaries(plan, input.workspaceRoot);
   } catch (error) {
@@ -17851,19 +18913,7 @@ function compileFleetRunPreview(input) {
           }
         ];
       }
-      let route = null;
-      try {
-        route = input.resolveRoute?.({
-          stepId: step.id,
-          agentId: step.agentId,
-          task: step.task,
-          scope: step.scope,
-          ...step.target !== void 0 ? { target: step.target } : {},
-          ...step.profile !== void 0 ? { profile: step.profile } : {}
-        }) ?? null;
-      } catch (error) {
-        diagnostics.push(`step '${step.id}' route preflight failed: ${describeError(error)}`);
-      }
+      const route = routes.get(step.id) ?? null;
       return [
         {
           ...base,
@@ -18481,6 +19531,8 @@ function formatMemoryStatusLine(status, contentWidth) {
     theme6.fg("muted", `last ${status.lastDecision ?? "none"}`)
   ];
   if (status.stepInFlight) units.push(theme6.fg("reason", "step running"));
+  const spend = status.spend === null || status.spend === void 0 ? "" : formatTaskMemorySpend(status.spend);
+  if (spend.length > 0) units.push(theme6.fg("dim", spend));
   return fitUnits(theme6, "", units, width);
 }
 function bankEntries(snapshot) {
@@ -18577,7 +19629,8 @@ function memorySignature(status, records) {
     status.tier,
     String(status.size),
     status.lastDecision ?? "none",
-    status.stepInFlight ? "running" : "idle"
+    status.stepInFlight ? "running" : "idle",
+    `${status.spend?.llmSteps ?? 0}:${status.spend?.injections ?? 0}:${status.spend?.totalTokens ?? 0}`
   ];
   for (const record2 of records) parts.push(`r:${record2.id}:${record2.approved}:${record2.rejectedAt ?? ""}`);
   for (const entry of bankEntries(status.bank)) {
@@ -20552,6 +21605,15 @@ var SubmenuWrapper = class {
   child;
   hint;
   note;
+  /**
+   * Why the last submission was refused, or null while nothing is wrong. The
+   * editor sets it instead of closing, so the operator corrects the value with
+   * the reason on screen rather than back at the row list with no reason.
+   */
+  problem = null;
+  setProblem(problem) {
+    this.problem = problem;
+  }
   render(width) {
     const theme6 = clioTheme();
     const lines = [];
@@ -20565,6 +21627,11 @@ var SubmenuWrapper = class {
     }
     lines.push("");
     lines.push(...this.child.render(Math.max(1, width - 2)).map((line) => `  ${line}`));
+    if (this.problem !== null) {
+      for (const line of wrapTextWithAnsi(this.problem, Math.max(1, width - 2))) {
+        lines.push(theme6.fg("error", `  ${line}`));
+      }
+    }
     lines.push("");
     lines.push(theme6.fg("dim", `  ${this.hint}`));
     return lines;
@@ -20628,31 +21695,63 @@ function selectModelSubmenu(providers, getActiveTarget) {
 function editTextSubmenu(title, note) {
   return textInputSubmenu(title, note);
 }
-function editNumberSubmenu(title, options = {}) {
-  const min = options.min ?? 0;
+var NUMBER_SETTING_RULES = {
+  "budget.sessionCeilingUsd": { min: 0, integer: false },
+  "watchdog.cadenceToolCalls": { min: 1, integer: true, allowBlank: true },
+  "delegation.defaults.connectTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+  "delegation.defaults.turnTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true },
+  "delegation.defaults.permissionTimeoutMs": { min: 1, max: MAX_TIMER_DELAY_MS, integer: true }
+};
+var NUMBER_SETTING_IDS = Object.keys(NUMBER_SETTING_RULES);
+function describeSubmittedText(value) {
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? "an empty string" : JSON.stringify(trimmed);
+}
+function parseNumberSetting(value, rule2) {
+  const trimmed = value.trim();
+  const noun = rule2.integer ? "an integer" : "a number";
+  if (trimmed.length === 0 && rule2.allowBlank === true) return { value: null };
+  const parsed = trimmed.length === 0 ? Number.NaN : Number(trimmed);
+  if (!Number.isFinite(parsed) || rule2.integer && !Number.isInteger(parsed)) {
+    const shown = Number.isFinite(parsed) ? String(parsed) : describeSubmittedText(value);
+    return { refusal: `Not applied: expected ${noun}, got ${shown}.` };
+  }
+  if (parsed < rule2.min) return { refusal: `Not applied: expected ${noun} >= ${rule2.min}, got ${parsed}.` };
+  if (rule2.max !== void 0 && parsed > rule2.max) {
+    return { refusal: `Not applied: expected ${noun} <= ${rule2.max}, got ${parsed}.` };
+  }
+  return { value: parsed };
+}
+function numberSettingNote(rule2) {
+  const noun = rule2.integer ? "a whole number" : "a number";
+  const clears = rule2.allowBlank === true ? "; blank clears it" : "";
+  if (rule2.min > 0 && rule2.max !== void 0) return `Use ${noun} from ${rule2.min} to ${rule2.max}${clears}.`;
+  if (rule2.min > 0) return `Use ${noun} of at least ${rule2.min}${clears}.`;
+  return `Use a non-negative ${rule2.integer ? "whole number" : "number"}${clears}.`;
+}
+function editNumberSubmenu(title, id) {
+  const rule2 = NUMBER_SETTING_RULES[id];
   return (currentValue, done) => {
     const input = new Input();
     input.setValue(currentValue);
     input.focused = true;
+    const wrapper = new SubmenuWrapper(
+      title,
+      input,
+      buildHint([{ key: "Enter", verb: "confirm" }], "back"),
+      numberSettingNote(rule2)
+    );
     input.onSubmit = (val) => {
-      if (options.allowBlank === true && val.trim().length === 0) {
-        done("");
+      const outcome = parseNumberSetting(val, rule2);
+      if ("refusal" in outcome) {
+        wrapper.setProblem(outcome.refusal);
         return;
       }
-      const num = Number(val);
-      if (Number.isFinite(num) && num >= min) {
-        done(val);
-      } else {
-        done();
-      }
+      wrapper.setProblem(null);
+      done(outcome.value === null ? "" : val.trim());
     };
     input.onEscape = () => done();
-    return new SubmenuWrapper(
-      title,
-      input,
-      buildHint([{ key: "Enter", verb: "confirm" }], "back"),
-      min > 0 ? `Use a whole number of at least ${min}${options.allowBlank === true ? "; blank clears it" : ""}.` : "Use a non-negative number."
-    );
+    return wrapper;
   };
 }
 function selectListSubmenu(title, items, note) {
@@ -21189,6 +22288,7 @@ function buildSettingItems(settings, options) {
     }),
     fleetGroupHeader("fleet.group.placement", "Placement"),
     ...fleetNodeRows(options?.getFleetNodes?.() ?? []),
+    ...fleetEndpointRows(options?.providers),
     settingItem("targets", "", {
       description: "Live inference target inventory and routing roles.",
       affordance: "column heading",
@@ -21210,7 +22310,7 @@ function buildSettingItems(settings, options) {
       readOnly: true
     }),
     settingItem("budget.sessionCeilingUsd", String(settings.budget.sessionCeilingUsd), {
-      submenu: editNumberSubmenu("Edit session cost ceiling USD"),
+      submenu: editNumberSubmenu("Edit session cost ceiling USD", "budget.sessionCeilingUsd"),
       affordance: "free text"
     }),
     settingItem("defaults.maxTokens", String(settings.defaults.maxTokens), {
@@ -21277,10 +22377,10 @@ function buildSettingItems(settings, options) {
       "watchdog.cadenceToolCalls",
       watchdog.cadenceToolCalls === void 0 ? "(turn end only)" : String(watchdog.cadenceToolCalls),
       {
-        submenu: editNumberSubmenu("Edit watchdog cadence in tool calls; blank fires at turn end only", {
-          min: 1,
-          allowBlank: true
-        }),
+        submenu: editNumberSubmenu(
+          "Edit watchdog cadence in tool calls; blank fires at turn end only",
+          "watchdog.cadenceToolCalls"
+        ),
         affordance: "free text",
         editValue: watchdog.cadenceToolCalls === void 0 ? "" : String(watchdog.cadenceToolCalls)
       }
@@ -21301,15 +22401,15 @@ function buildSettingItems(settings, options) {
       affordance: "free text"
     }),
     settingItem("delegation.defaults.connectTimeoutMs", String(settings.delegation.defaults.connectTimeoutMs), {
-      submenu: editNumberSubmenu("Edit delegate connect timeout (ms)"),
+      submenu: editNumberSubmenu("Edit delegate connect timeout (ms)", "delegation.defaults.connectTimeoutMs"),
       affordance: "free text"
     }),
     settingItem("delegation.defaults.turnTimeoutMs", String(settings.delegation.defaults.turnTimeoutMs), {
-      submenu: editNumberSubmenu("Edit delegate turn timeout (ms)"),
+      submenu: editNumberSubmenu("Edit delegate turn timeout (ms)", "delegation.defaults.turnTimeoutMs"),
       affordance: "free text"
     }),
     settingItem("delegation.defaults.permissionTimeoutMs", String(settings.delegation.defaults.permissionTimeoutMs), {
-      submenu: editNumberSubmenu("Edit delegate permission timeout (ms)"),
+      submenu: editNumberSubmenu("Edit delegate permission timeout (ms)", "delegation.defaults.permissionTimeoutMs"),
       affordance: "free text"
     }),
     settingItem("keybindings", keybindingCount > 0 ? `${keybindingCount} override(s)` : "(defaults)", {
@@ -21527,6 +22627,32 @@ function fleetNodeRows(nodes) {
     });
   });
 }
+function fleetEndpointRows(providers) {
+  if (providers === void 0) return [];
+  let usage = {};
+  try {
+    usage = capacityLeaseUsage().endpoints;
+  } catch {
+  }
+  const capacities = endpointCapacitiesForStatuses(providers.list());
+  const targetsByEndpoint = /* @__PURE__ */ new Map();
+  for (const status of providers.list()) {
+    const endpoint = endpointCapacityForStatus(status);
+    if (endpoint === null) continue;
+    targetsByEndpoint.set(endpoint.key, [...targetsByEndpoint.get(endpoint.key) ?? [], status.target.id]);
+  }
+  return Object.entries(capacities).map(([key, endpoint]) => {
+    const slots = `slots ${usage[key] ?? 0}/${endpoint.limit}`;
+    return settingItem(`fleet.endpoints.${key}`, slots, {
+      label: `endpoint ${endpoint.label}`,
+      description: `Targets: ${(targetsByEndpoint.get(key) ?? []).join(", ")} \xB7 Limit source: ${endpoint.source}`,
+      affordance: "read-only inference endpoint capacity",
+      readOnly: true,
+      presentationKind: "status",
+      valueSegments: [{ text: slots, tone: "neutral" }]
+    });
+  });
+}
 function buildSettingsSections(items) {
   return SETTINGS_SECTIONS.map((section2) => ({
     id: section2.id,
@@ -21572,9 +22698,10 @@ function applyNonNegativeInteger(value, set) {
   const parsed = Number(value);
   if (Number.isFinite(parsed) && parsed >= 0) set(Math.floor(parsed));
 }
-function applyPositiveInteger(value, set) {
-  const parsed = Number(value);
-  if (Number.isInteger(parsed) && parsed >= 1 && parsed <= MAX_TIMER_DELAY_MS) set(parsed);
+function applyNumberSetting(id, value, set) {
+  const outcome = parseNumberSetting(value, NUMBER_SETTING_RULES[id]);
+  if ("refusal" in outcome) return;
+  set(outcome.value);
 }
 function applyDelegationAgentChange(settings, value) {
   if (value.startsWith(DELEGATION_REMOVE_PREFIX)) {
@@ -21733,15 +22860,12 @@ function applySettingChange(settings, id, value) {
       else delete settings.watchdog.target;
       return;
     }
-    case "watchdog.cadenceToolCalls": {
-      if (value.trim().length === 0) {
-        delete settings.watchdog.cadenceToolCalls;
-        return;
-      }
-      const parsed = Number(value);
-      if (Number.isFinite(parsed) && Math.floor(parsed) >= 1) settings.watchdog.cadenceToolCalls = Math.floor(parsed);
+    case "watchdog.cadenceToolCalls":
+      applyNumberSetting("watchdog.cadenceToolCalls", value, (next) => {
+        if (next === null) delete settings.watchdog.cadenceToolCalls;
+        else settings.watchdog.cadenceToolCalls = next;
+      });
       return;
-    }
     case "terminal.smoothStreaming":
       if (value === "off" || value === "auto" || value === "on") settings.terminal.smoothStreaming = value;
       return;
@@ -21749,18 +22873,18 @@ function applySettingChange(settings, id, value) {
       settings.runtimePlugins = value.split(",").map((entry) => entry.trim()).filter(Boolean);
       return;
     case "delegation.defaults.connectTimeoutMs":
-      applyPositiveInteger(value, (next) => {
-        settings.delegation.defaults.connectTimeoutMs = next;
+      applyNumberSetting("delegation.defaults.connectTimeoutMs", value, (next) => {
+        if (next !== null) settings.delegation.defaults.connectTimeoutMs = next;
       });
       return;
     case "delegation.defaults.turnTimeoutMs":
-      applyPositiveInteger(value, (next) => {
-        settings.delegation.defaults.turnTimeoutMs = next;
+      applyNumberSetting("delegation.defaults.turnTimeoutMs", value, (next) => {
+        if (next !== null) settings.delegation.defaults.turnTimeoutMs = next;
       });
       return;
     case "delegation.defaults.permissionTimeoutMs":
-      applyPositiveInteger(value, (next) => {
-        settings.delegation.defaults.permissionTimeoutMs = next;
+      applyNumberSetting("delegation.defaults.permissionTimeoutMs", value, (next) => {
+        if (next !== null) settings.delegation.defaults.permissionTimeoutMs = next;
       });
       return;
     case "orchestrator.target": {
@@ -21799,11 +22923,11 @@ function applySettingChange(settings, id, value) {
     case "scope":
       settings.scope = parseScopedModelSelection(value) ?? value.split(",").map((v) => v.trim()).filter(Boolean);
       return;
-    case "budget.sessionCeilingUsd": {
-      const parsed = Number(value);
-      if (Number.isFinite(parsed) && parsed >= 0) settings.budget.sessionCeilingUsd = parsed;
+    case "budget.sessionCeilingUsd":
+      applyNumberSetting("budget.sessionCeilingUsd", value, (next) => {
+        if (next !== null) settings.budget.sessionCeilingUsd = next;
+      });
       return;
-    }
   }
 }
 function applyEntrySettingChange(settings, id, value) {
@@ -24718,6 +25842,8 @@ ${usage}` : usage);
       const result = ctx.verifyReceipt(command.runId);
       if (result.ok) {
         ctx.notice("success", `verify ok ${command.runId}`);
+      } else if (result.retired !== void 0) {
+        ctx.notice("warn", `verify retired ${command.runId} ${result.reason}`);
       } else {
         ctx.notice("error", `verify fail ${command.runId} ${result.reason}`);
       }
@@ -24966,8 +26092,8 @@ function dispatchSlashCommand(command, ctx) {
       ctx.submitChat(command.text);
       return "accepted";
     }
-    const refusal = expansion?.expanded === false ? expansion.refusal : void 0;
-    ctx.notice("error", refusal ? refusal.message : `/${command.token} is not a command. Type /help for the list.`);
+    const refusal2 = expansion?.expanded === false ? expansion.refusal : void 0;
+    ctx.notice("error", refusal2 ? refusal2.message : `/${command.token} is not a command. Type /help for the list.`);
     ctx.render();
     return "rejected";
   }
@@ -25418,7 +26544,10 @@ function createOverlayGeneralOpeners(deps) {
     if (deps.transitions.state !== "closed") return;
     deps.transitions.state = "cost";
     deps.transitions.handle = openCostOverlayFactory(deps.tui, deps.observability, {
-      sessionId: deps.getSessionId?.() ?? null
+      sessionId: deps.getSessionId?.() ?? null,
+      ...deps.readSessionEntries ? {
+        getSessionEntries: () => deps.readSessionEntries?.() ?? []
+      } : {}
     });
     deps.requestRender();
   };
@@ -25663,10 +26792,17 @@ function createOverlayGeneralOpeners(deps) {
         };
         const resolution = deps.dispatch.preview?.(request);
         if (!resolution) return null;
+        const foregroundHeld = resolution.endpoint === void 0 ? 0 : foregroundStreamUsage()[resolution.endpoint.key] ?? 0;
         return {
           targetId: resolution.targetId,
           wireModelId: resolution.wireModelId,
-          nodeId: resolution.node.id
+          nodeId: resolution.node.id,
+          ...resolution.endpoint !== void 0 ? {
+            endpoint: {
+              ...resolution.endpoint,
+              ...foregroundHeld > 0 ? { foregroundHeld } : {}
+            }
+          } : {}
         };
       }
     });
@@ -25853,12 +26989,41 @@ function permissionOverlayPlacement(tui, editor, footer) {
   };
 }
 var PermissionOverlayBody = class {
-  constructor(view) {
+  constructor(view, inspect) {
     this.view = view;
+    this.inspect = inspect;
   }
   view;
+  inspect;
+  preview = null;
+  scroll = 0;
+  lastLineCount = 0;
+  canInspect() {
+    return this.inspect !== void 0;
+  }
+  isInspecting() {
+    return this.preview !== null;
+  }
+  toggleInspect() {
+    if (this.inspect === void 0) return;
+    if (this.preview !== null) {
+      this.preview = null;
+      this.scroll = 0;
+      return;
+    }
+    this.preview = this.inspect();
+    this.scroll = 0;
+  }
+  scrollInspect(delta) {
+    if (this.preview === null) return;
+    const maxScroll = Math.max(0, this.lastLineCount - MUTATION_PREVIEW_VISIBLE_ROWS);
+    this.scroll = Math.max(0, Math.min(this.scroll + delta, maxScroll));
+  }
   render(width) {
-    return permissionOverlayLines(this.view, width);
+    if (this.preview === null) return permissionOverlayLines(this.view, width);
+    const rendered = permissionInspectionLines(this.view, this.preview, width, this.scroll);
+    this.lastLineCount = rendered.wrappedLineCount;
+    return rendered.lines;
   }
   invalidate() {
   }
@@ -25919,18 +27084,66 @@ function permissionOverlayTitle(view) {
 function permissionOverlayTone(view) {
   return permissionDecisionPresentation(view).semanticToken;
 }
-function permissionOverlayHint(innerWidth, composerHasDraft = false) {
-  return fitHintEntries(permissionHintEntries(composerHasDraft), innerWidth - 3);
+function permissionOverlayHint(innerWidth, composerHasDraft = false, inspection = "none") {
+  return fitHintEntries(permissionHintEntries(composerHasDraft, inspection), innerWidth - 3);
+}
+function isFileMutationTool(tool) {
+  return tool === "write" || tool === "edit";
 }
 function actionConsequence(presentation, id) {
   return presentation.requiredActions.find((action) => action.id === id)?.consequence ?? "";
 }
+function wrapMutationLine(value, max) {
+  if (max <= 1) return [value];
+  if (value.length <= max) return [value];
+  const lines = [];
+  let remaining = value;
+  while (remaining.length > max) {
+    lines.push(`${remaining.slice(0, max - 1)}\u21A9`);
+    remaining = remaining.slice(max - 1);
+  }
+  lines.push(remaining);
+  return lines;
+}
+function permissionInspectionLines(view, preview, width, scroll) {
+  const content = Math.max(8, Math.floor(width));
+  const wrapped = preview.body.flatMap((line) => wrapMutationLine(line, content));
+  const pane = mutationPreviewWindow(wrapped, scroll);
+  const notes = [];
+  if (preview.neutralized) notes.push("control characters shown as \xB7");
+  if (preview.tabsExpanded) notes.push("tabs shown as spaces");
+  const lines = [
+    field("Tool: ", `${view.tool} \xB7 Action: ${view.actionClass}`, content),
+    ...view.target !== void 0 && view.target.length > 0 ? [field("Target: ", view.target, content)] : [],
+    ...wrapSentence(`Mutation: ${mutationFactsLine(preview.facts)}`, content),
+    "",
+    ...wrapSentence(preview.heading, content),
+    ...pane.window,
+    ...pane.position === null ? [] : [pane.position],
+    ...notes.length > 0 ? [`Rendered safely: ${notes.join(", ")}.`] : []
+  ];
+  return { lines, wrappedLineCount: wrapped.length };
+}
 function permissionOverlayLines(view, width) {
   const content = Math.max(8, Math.floor(width));
   const presentation = permissionDecisionPresentation(view);
   const lines = [
     field("Tool: ", `${view.tool} \xB7 Action: ${view.actionClass}`, content),
     ...view.target !== void 0 && view.target.length > 0 ? [field("Target: ", view.target, content)] : [],
+    // Size and digest stay on the collapsed card whether or not the operator
+    // opens the mutation, so the decision always carries the identity of the
+    // bytes it applies to.
+    // Wrapped, never ellipsized: at 40 columns the digest is the tail of the
+    // line, and ellipsizing it would drop the one fact that ties the decision
+    // to the bytes it applies to.
+    ...view.mutation !== void 0 ? [
+      ...wrapSentence(`Mutation: ${mutationFactsLine(view.mutation)}`, content),
+      ...wrapSentence(`Press ${MUTATION_PREVIEW_KEY} to read it before deciding.`, content)
+    ] : [],
+    ...view.mutation === void 0 && view.origin.kind === "worker" && isFileMutationTool(view.tool) ? wrapSentence(
+      "No local preview: this call's arguments stay inside the worker, so you are approving the target above without inspecting the mutation.",
+      content
+    ) : [],
     ...wrapSentence(`Requested by: ${presentation.requestedByCopy}`, content),
     ...view.artifact !== void 0 ? [
       "",
@@ -25950,8 +27163,8 @@ function permissionOverlayLines(view, width) {
   }
   return lines;
 }
-function createPermissionOverlayBody(view) {
-  return new PermissionOverlayBody(view);
+function createPermissionOverlayBody(view, inspect) {
+  return new PermissionOverlayBody(view, inspect);
 }
 
 // src/interactive/bus-notices.ts
@@ -26172,6 +27385,7 @@ function mainApprovalRequestView(call, decision, meta, autonomy, queueDepth) {
   const axisFromDecision = askAxis(decision);
   const axis = axisFromMeta ?? (axisFromDecision.kind === "net" ? { kind: "net", ruleId: axisFromDecision.ruleId } : { kind: "autonomy", level: autonomy });
   const target = describeCallTarget(call.tool, call.args);
+  const mutation = mutationFacts(call.tool, call.args);
   return {
     requestId: meta?.requestId ?? "permission-pending",
     tool: call.tool,
@@ -26182,9 +27396,14 @@ function mainApprovalRequestView(call, decision, meta, autonomy, queueDepth) {
     ...call.tool === ToolNames.Dispatch && decision.kind === "ask" ? { artifact: { kind: "dispatch-plan", text: decision.rejection.detail } } : {},
     ...call.tool === ToolNames.AskUser ? { exposure: askUserExposure(call.args) } : {},
     ...target.length > 0 ? { target } : {},
+    ...mutation !== null ? { mutation } : {},
     ...queueDepth !== void 0 && queueDepth > 1 ? { queueDepth } : {}
   };
 }
+function mainMutationInspector(call, view) {
+  if (view.mutation === void 0) return void 0;
+  return createMutationInspector(call.tool, call.args, view.mutation);
+}
 function workerEscalationEntry(payload, autonomy) {
   if (!isLiveWorkerEscalationRequest(payload) || typeof payload.requestId !== "string") return null;
   const origin = typeof payload.origin === "string" ? payload.origin : void 0;
@@ -26258,7 +27477,7 @@ function createOverlayPermissionLifecycle(deps) {
       announceParked();
       return;
     }
-    if (!deps.openPermissionOverlay(view)) {
+    if (!deps.openPermissionOverlay(view, mainMutationInspector(call, view))) {
       announceParked();
       return;
     }
@@ -26646,7 +27865,8 @@ function openHelpOverlay(tui, manager, onClose, initialFilter) {
         "**Tool surface**: which tools exist at all through registration, tool profiles, skill narrowing, and dispatch admission. Violations are terminal denials, never approvable.",
         "**Safety net** (always on, level-independent): damage-control rules, path policy for secrets and system paths, command-substitution confirmation, and `git_destructive` blocks. Blocks are final at every level; confirm rails ask at every level.",
         "**Autonomy level** (`/settings`, persisted as `autonomy`): the operator's standing grant per action class for actions the net passed, enforced by the harness at tool admission. read-only denies non-read, suggest parks every non-read call, auto-edit parks unrecognized commands, and full-auto runs them.",
-        "**Approvals**: a parked call waits for a one-shot operator decision; approving resumes only that call. Workers resolve asks per `workers.onPermission` (Approvals Routing); headless runs auto-deny."
+        "**Approvals**: a parked call waits for a one-shot operator decision; approving resumes only that call. Workers resolve asks per `workers.onPermission` (Approvals Routing); headless runs auto-deny.",
+        "**Inspecting a mutation**: a parked `write` or `edit` card carries the target, the byte count, and a `sha256` digest of the exact call arguments. Press `v` to read the complete proposed content, or the complete effective diff against the file on disk, and `v` again to put it away; \u2191/\u2193 and PageUp/PageDown scroll it. Enter still allows, `s` still stops, and Esc still denies while it is open. The mutation text is shown locally and never enters the transcript, a notice, a desktop notification, or the render trace. A worker escalation has no preview because the call's arguments never leave the worker, and its card says so."
       ]
     }
   ];
@@ -26779,13 +27999,16 @@ function openPromptsOverlay(tui, ctx, onClose) {
           lines.push(`**Argument Hint:** \`${template.argumentHint}\``);
         }
         lines.push(`**Source:** ${template.sourceInfo.source ?? template.sourceInfo.scope}`);
+        if (template.unavailable !== void 0) {
+          lines.push(`**Unavailable:** ${template.unavailable}`);
+        }
         if (!template.trusted) {
           lines.push("**Untrusted:** set `skills.trustProjectCompatRoots` before this template will expand.");
         }
         return lines;
       }
     };
-    const marker = template.trusted ? void 0 : clioTheme().fg("warning", "untrusted");
+    const marker = template.unavailable !== void 0 ? clioTheme().fg("error", "unavailable") : template.trusted ? void 0 : clioTheme().fg("warning", "untrusted");
     if (marker) item.meta = template.argumentHint ? `${template.argumentHint} \xB7 ${marker}` : marker;
     else if (template.argumentHint) item.meta = template.argumentHint;
     return item;
@@ -26945,7 +28168,7 @@ function runCompactWithNotice(onCompact, notice, instructions) {
 init_esm_shims();
 import { spawnSync } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { readFileSync as readFileSync7, unlinkSync, writeFileSync } from "node:fs";
+import { readFileSync as readFileSync8, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join7 } from "node:path";
 function defaultProbe(candidates) {
@@ -26985,7 +28208,7 @@ function editTextExternally(initialText, command) {
     const result = runEditor(command, tmpFile);
     if (result.error) return { ok: false, error: result.error.message };
     if (result.status !== 0) return { ok: false, error: `external editor exited with code ${result.status ?? "?"}` };
-    return { ok: true, text: readFileSync7(tmpFile, "utf8").replace(/\n$/, "") };
+    return { ok: true, text: readFileSync8(tmpFile, "utf8").replace(/\n$/, "") };
   } finally {
     try {
       unlinkSync(tmpFile);
@@ -28242,19 +29465,54 @@ function createOverlaySessionLifecycle(deps) {
     }
     void runHandoffExtraction(session, fromSessionId, verdict.goal);
   }
+  const HANDOFF_REFUSAL_QUOTE_CHARS = 200;
+  function terminalHandoffRefusal(firstReason, secondReason, secondText) {
+    const answered = secondText.replace(/\s+/g, " ").trim().slice(0, HANDOFF_REFUSAL_QUOTE_CHARS);
+    return [
+      "the extraction round could not produce a handoff record after one repair attempt.",
+      `Asked for: one JSON object with decisions, facts, files, commands, and openQuestions.`,
+      `Round 1: ${firstReason}.`,
+      `Round 2: ${secondReason}.`,
+      `Round 2 returned: ${answered.length > 0 ? answered : "(nothing)"}`
+    ].join(" ");
+  }
+  async function extractWithOneRepair(goal) {
+    const first = await deps.chat.extractHandoff(goal);
+    if (first.status !== "answered") {
+      return {
+        ok: false,
+        level: first.status === "failed" ? "error" : "warn",
+        reason: first.status === "aborted" ? "the extraction round was cancelled" : first.reason
+      };
+    }
+    const parsedFirst = parseHandoffExtraction(first.text);
+    if (parsedFirst.ok) return { ok: true, parsed: parsedFirst };
+    const second = await deps.chat.extractHandoff(goal, {
+      repair: { complaint: parsedFirst.reason, previous: first.text }
+    });
+    if (second.status !== "answered") {
+      return {
+        ok: false,
+        level: second.status === "failed" ? "error" : "warn",
+        reason: second.status === "aborted" ? "the repair round was cancelled" : `round 1 could not be read (${parsedFirst.reason}); the repair round then failed: ${second.reason}`
+      };
+    }
+    const parsedSecond = parseHandoffExtraction(second.text);
+    if (parsedSecond.ok) return { ok: true, parsed: parsedSecond };
+    return {
+      ok: false,
+      level: "error",
+      reason: terminalHandoffRefusal(parsedFirst.reason, parsedSecond.reason, second.text)
+    };
+  }
   async function runHandoffExtraction(session, fromSessionId, goal) {
     const notice = deps.getSlashNotice();
-    const outcome = await deps.chat.extractHandoff(goal);
-    if (outcome.status !== "answered") {
-      const reason = outcome.status === "aborted" ? "the extraction round was cancelled" : outcome.reason;
-      emitCommandNotice(notice, outcome.status === "failed" ? "error" : "warn", "handoff", reason);
-      return;
-    }
-    const parsed = parseHandoffExtraction(outcome.text);
-    if (!parsed.ok) {
-      emitCommandNotice(notice, "error", "handoff", parsed.reason);
+    const extraction = await extractWithOneRepair(goal);
+    if (!extraction.ok) {
+      emitCommandNotice(notice, extraction.level, "handoff", extraction.reason);
       return;
     }
+    const parsed = extraction.parsed;
     const meta = session.current();
     const cwd = typeof meta?.cwd === "string" && meta.cwd.length > 0 ? meta.cwd : null;
     const entries = deps.readStructuredEntries(fromSessionId);
@@ -28433,6 +29691,14 @@ var DRAFT_EDIT_KEYS = ["backspace", "delete", "ctrl+u", "ctrl+w", "alt+backspace
 function isDraftEditKey(data) {
   return !isKeyRelease(data) && DRAFT_EDIT_KEYS.some((key) => matchesKey(data, key));
 }
+var MUTATION_PAGE_ROWS = 16;
+function mutationScrollDelta(data) {
+  if (matchesKey(data, "up")) return -1;
+  if (matchesKey(data, "down")) return 1;
+  if (matchesKey(data, "pageUp")) return -MUTATION_PAGE_ROWS;
+  if (matchesKey(data, "pageDown")) return MUTATION_PAGE_ROWS;
+  return 0;
+}
 function routePermissionOverlayKey(data, deps) {
   if (matchesKey(data, "enter") && !isKeyRelease(data)) {
     if (!(deps.composerHasDraft?.() ?? false)) deps.confirmPermission();
@@ -28442,6 +29708,17 @@ function routePermissionOverlayKey(data, deps) {
     deps.editDraft(data);
     return true;
   }
+  if (matchesKey(data, MUTATION_PREVIEW_KEY) && !isKeyRelease(data) && (deps.canInspectMutation?.() ?? false) && deps.toggleMutationInspection) {
+    deps.toggleMutationInspection();
+    return true;
+  }
+  if ((deps.isInspectingMutation?.() ?? false) && deps.scrollMutationInspection && !isKeyRelease(data)) {
+    const delta = mutationScrollDelta(data);
+    if (delta !== 0) {
+      deps.scrollMutationInspection(delta);
+      return true;
+    }
+  }
   if (isEscapeKey(data)) {
     deps.cancelPermission();
     return true;
@@ -28616,6 +29893,11 @@ function createOverlayLifecycle(deps) {
   } = deps;
   let overlayPermission = null;
   let overlayAskUser = null;
+  let permissionBody = null;
+  const inspectionHint = () => {
+    if (permissionBody === null || !permissionBody.canInspect()) return "none";
+    return permissionBody.isInspecting() ? "open" : "closed";
+  };
   const overlayTransitions = createOverlayTransitions({
     stopDispatchBoardTicker: () => interactiveTickers.stopDispatchBoardTicker(),
     renderContextIsland: () => interactiveTickers.renderContextIsland(),
@@ -28623,7 +29905,10 @@ function createOverlayLifecycle(deps) {
     requestRender: () => tui.requestRender(),
     cancelPendingAskUser: () => overlayAskUser?.cancelPending() ?? false,
     finishAuth: (dismiss) => overlayAuth.finish(dismiss),
-    onPermissionOverlayClosed: () => overlayPermission?.onPermissionOverlayClosed(),
+    onPermissionOverlayClosed: () => {
+      permissionBody = null;
+      overlayPermission?.onPermissionOverlayClosed();
+    },
     onOverlayClosed: () => overlayPermission?.retryPending()
   });
   const closeOverlay = overlayTransitions.close;
@@ -28652,17 +29937,20 @@ function createOverlayLifecycle(deps) {
     dispatch: deps.app.dispatch,
     getAutonomy: () => deps.app.getSettings?.().autonomy ?? "auto-edit",
     getOverlayState: () => overlayTransitions.state,
-    openPermissionOverlay: (view) => {
+    openPermissionOverlay: (view, inspect) => {
       if (overlayTransitions.state !== "closed") return false;
       overlayTransitions.state = "permission-confirm";
-      overlayTransitions.handle = showOverlayFrame(tui, createPermissionOverlayBody(view), {
+      const body = createPermissionOverlayBody(view, inspect);
+      permissionBody = body;
+      overlayTransitions.handle = showOverlayFrame(tui, body, {
         ...permissionOverlayPlacement(tui, editor, footer.view),
         width: PERMISSION_OVERLAY_WIDTH,
         title: permissionOverlayTitle(view),
         tone: permissionOverlayTone(view),
         // Read per frame: the footer names what Enter does right now, and
-        // that depends on whether the composer holds a draft.
-        footerHint: (innerWidth) => permissionOverlayHint(innerWidth, editor.getText().length > 0)
+        // that depends on whether the composer holds a draft and on whether
+        // the mutation is open.
+        footerHint: (innerWidth) => permissionOverlayHint(innerWidth, editor.getText().length > 0, inspectionHint())
       });
       tui.requestRender();
       return true;
@@ -28860,6 +30148,16 @@ function createOverlayLifecycle(deps) {
       footer.refresh();
       tui.requestRender();
     },
+    canInspectMutation: () => permissionBody?.canInspect() ?? false,
+    isInspectingMutation: () => permissionBody?.isInspecting() ?? false,
+    toggleMutationInspection: () => {
+      permissionBody?.toggleInspect();
+      tui.requestRender();
+    },
+    scrollMutationInspection: (delta) => {
+      permissionBody?.scrollInspect(delta);
+      tui.requestRender();
+    },
     cancelAskUser: overlayAskUser.cancel,
     dispose: () => {
       overlayPermission?.dispose();
@@ -30083,6 +31381,14 @@ function createInteractiveEventProjection(deps) {
     })
   );
   remainingUnsubscribers.push(
+    deps.bus.on(BusChannels.DispatchScopeNotice, (payload) => {
+      const event = payload;
+      if (!event || typeof event !== "object" || !["typed_scope_replaced_inferred_paths", "legacy_scope_inferred", "legacy_scope_empty"].includes(event.code) || typeof event.message !== "string") {
+        return;
+      }
+      deps.appendTranscriptNotice("warn", event.message);
+      deps.requestRender();
+    }),
     deps.bus.on(BusChannels.LoopBlocked, (payload) => {
       const event = payload;
       if (!event || typeof event !== "object" || typeof event.tool !== "string" || typeof event.repeatCount !== "number") {
@@ -30374,6 +31680,10 @@ function createInteractiveInputRuntime(deps) {
         confirmPermission: () => deps.overlay.confirmPermission(),
         stopTurnFromPermission: () => deps.overlay.stopTurnFromPermission(),
         composerHasDraft: () => deps.editor.getText().length > 0,
+        canInspectMutation: () => deps.overlay.canInspectMutation(),
+        isInspectingMutation: () => deps.overlay.isInspectingMutation(),
+        toggleMutationInspection: () => deps.overlay.toggleMutationInspection(),
+        scrollMutationInspection: (delta) => deps.overlay.scrollMutationInspection(delta),
         editDraft: (data2) => {
           deps.editor.handleInput?.(data2);
           deps.requestRender();
@@ -31205,11 +32515,23 @@ function renderErrorSegmentLines(seg, width) {
 var CLIO_PREFIX = `${TEAL}${AGENT_GLYPH}${RESET} `;
 var CLIO_PREFIX_ERROR = `${RED_CRIT}${AGENT_GLYPH}${RESET} `;
 var USER_PREFIX = `${TEAL}${USER_GLYPH}${RESET} `;
+var USER_PREFIX_PENDING = `${DIM}${USER_GLYPH}${RESET} `;
+var USER_PENDING_TAIL = " \xB7 preparing";
+var USER_REFUSED_TAIL = " \xB7 not sent";
 var PROSE_GUTTER = "  ";
 var PROSE_GUTTER_WIDTH = 2;
 function hangProseLines(lines, firstPrefix) {
   return lines.map((line, index) => `${index === 0 && firstPrefix !== void 0 ? firstPrefix : PROSE_GUTTER}${line}`);
 }
+function appendUserRowTail(rendered, tail, width) {
+  const last = rendered.length - 1;
+  const lastLine = rendered[last];
+  if (lastLine !== void 0 && visibleWidth(lastLine) + tail.length <= width) {
+    rendered[last] = `${lastLine}${DIM}${tail}${RESET}`;
+    return;
+  }
+  rendered.push(`${PROSE_GUTTER}${dimLine(tail.trimStart(), Math.max(1, width - PROSE_GUTTER_WIDTH))}`);
+}
 var THINKING_HIDDEN_LABEL = `Thinking${GLYPH.ellipsis}`;
 var THINKING_LINE_LIMIT = 12;
 function dimLine(text, width) {
@@ -31366,8 +32688,11 @@ function renderEntryLines(entry, width, expandKey, latestHintToolId, latestFolde
     const contentWidth = Math.max(1, width - PROSE_GUTTER_WIDTH);
     const lines2 = [];
     for (const sourceLine of entry.text.split("\n")) lines2.push(...wrapTextWithAnsi(sourceLine, contentWidth));
-    const rendered = hangProseLines(lines2, USER_PREFIX);
+    const status = entry.status?.() ?? "committed";
+    const rendered = hangProseLines(lines2, status === "committed" ? USER_PREFIX : USER_PREFIX_PENDING);
     if (rendered[0] !== void 0) rendered[0] = `${OSC133_PROMPT_START}${rendered[0]}`;
+    if (status !== "committed")
+      appendUserRowTail(rendered, status === "pending" ? USER_PENDING_TAIL : USER_REFUSED_TAIL, width);
     return rendered;
   }
   if (entry.role === "retryStatus") {
@@ -31667,8 +32992,8 @@ function createChatPanel(options = {}) {
     (segment) => segment.kind === "tool" && !segment.finished && segment.startedAtMs !== void 0
     // The live reasoning line counts its own elapsed, so a turn that is
     // only thinking still needs the time-keyed render key.
-  ) || entry.pending && openThinkingSegment(entry)?.startedAtMs !== void 0) || entry.role === "replayBlock" && entry.isLive?.() === true;
-  const entryIsStable = (entry) => entry.role === "user" || entry.role === "replayBlock" && entry.isLive?.() !== true || entry.role === "worker" && !entry.state.pending || entry.role === "assistant" && !entry.pending && !entry.segments.some((segment) => segment.kind === "tool" && !segment.finished);
+  ) || entry.pending && openThinkingSegment(entry)?.startedAtMs !== void 0) || entry.role === "replayBlock" && entry.isLive?.() === true || entry.role === "user" && (entry.status?.() ?? "committed") !== "committed";
+  const entryIsStable = (entry) => entry.role === "user" && (entry.status?.() ?? "committed") === "committed" || entry.role === "replayBlock" && entry.isLive?.() !== true || entry.role === "worker" && !entry.state.pending || entry.role === "assistant" && !entry.pending && !entry.segments.some((segment) => segment.kind === "tool" && !segment.finished);
   const render2 = (width) => {
     const startedAt = performance5.now();
     const expandKey = resolveExpandKey();
@@ -31750,8 +33075,8 @@ function createChatPanel(options = {}) {
     return out;
   };
   return {
-    appendUser(text) {
-      transcript.push({ role: "user", text });
+    appendUser(text, status) {
+      transcript.push({ role: "user", text, ...status ? { status } : {} });
       markDirty();
     },
     appendReplayBlock(renderBlock, isLive2, fold) {
@@ -32188,6 +33513,7 @@ init_esm_shims();
 var CONTEXT_ISLAND_WIDTH = 52;
 var PHASES = ["scan", "codewiki", "generate", "clio-md", "state", "done"];
 var WIKI_PHASES = ["codewiki", "generate", "state", "done"];
+var COMPACTION_PHASES = ["compact", "done"];
 var PHASE_LABELS = {
   scan: "scan",
   // "index" rather than "wiki": this phase is the codewiki index build, and
@@ -32196,6 +33522,7 @@ var PHASE_LABELS = {
   generate: "draft",
   "clio-md": "CLIO-CODER.md",
   state: "state",
+  compact: "compact",
   done: "done"
 };
 var WIKI_PHASE_LABELS = {
@@ -32210,8 +33537,9 @@ var KINDS = /* @__PURE__ */ new Set([
   "context-wiki",
   "compaction"
 ]);
-var PHASE_SET = new Set(PHASES);
+var PHASE_SET = /* @__PURE__ */ new Set([...PHASES, ...COMPACTION_PHASES]);
 function phasesFor(kind) {
+  if (kind === "compaction") return COMPACTION_PHASES;
   return kind === "context-wiki" ? WIKI_PHASES : PHASES;
 }
 function phaseLabel(kind, phase) {
@@ -33516,6 +34844,8 @@ function createInteractivePresentation(deps) {
     },
     isStreaming: () => deps.chat.isStreaming(),
     ...deps.isAwaitingApproval ? { isAwaitingApproval: deps.isAwaitingApproval } : {},
+    ...deps.getPermissionInspection ? { getPermissionInspection: deps.getPermissionInspection } : {},
+    getTurnPreparation: () => deps.chat.turnPreparation().phase,
     willEnterSteer: (text) => willEnterSteerActiveWork(deps, text),
     getSubmitKeyLabel: () => formatKeyLabel(keybindings.getKeys("tui.input.submit")[0], "Enter"),
     getNewlineKeyLabel: () => formatKeyLabel(keybindings.getKeys("tui.input.newLine")[0], "Shift+Enter")
@@ -34028,9 +35358,9 @@ function createInteractiveSlashRuntime(deps) {
       const willQueue = deps.chat.isStreaming();
       deps.recordSubmittedTurn();
       deps.refreshFooter();
-      if (!willQueue) deps.chatPanel.appendUser(sub.text);
+      let rowStatus = "pending";
+      if (!willQueue) deps.chatPanel.appendUser(sub.text, () => rowStatus);
       deps.requestRender();
-      deps.beforeSemanticSubmit?.();
       let acknowledgeAdmission = () => {
       };
       const admitted = new Promise((resolve7) => {
@@ -34041,13 +35371,26 @@ function createInteractiveSlashRuntime(deps) {
         ...sub.workingContextPaths.length > 0 ? { workingContextPaths: sub.workingContextPaths } : {},
         ...sub.pendingSkillRequests.length > 0 ? { pendingSkillRequests: sub.pendingSkillRequests } : {},
         ...awaitAdmission && willQueue ? { steering: "end-of-turn" } : {},
-        ...awaitAdmission ? { onAdmitted: acknowledgeAdmission } : {}
+        ...!willQueue ? {
+          onPreparationVisible: async () => {
+            deps.beforeSemanticSubmit?.();
+            await deps.settleVisibleFrame?.("submit-preparing");
+          }
+        } : {},
+        onAdmitted: () => {
+          rowStatus = "committed";
+          deps.requestRender();
+          if (awaitAdmission) acknowledgeAdmission();
+        }
       });
       const settlement = turn.then(() => deps.settleVisibleFrame?.("submit-return")).catch((err) => {
         const msg = err instanceof Error ? err.message : String(err);
         deps.io.stderr(`[interactive] chat failed: ${msg}
 `);
-      }).finally(deps.requestRender);
+      }).finally(() => {
+        if (rowStatus === "pending") rowStatus = willQueue ? "committed" : "refused";
+        deps.requestRender();
+      });
       return awaitAdmission ? Promise.race([admitted, settlement]) : settlement;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -34801,6 +36144,13 @@ async function createInteractiveApplication(deps) {
   });
   const { terminal, tui } = shell;
   const renderTrace = getActiveRenderTrace();
+  const dumpInputWedgeOnTerminate = renderTrace ? () => {
+    try {
+      writeInputWedgeDump(clioStateDir(), renderTrace.snapshotInputWedge());
+    } catch {
+    }
+  } : null;
+  if (dumpInputWedgeOnTerminate) process.on("SIGTERM", dumpInputWedgeOnTerminate);
   const visibleEventIngress = /* @__PURE__ */ new WeakMap();
   let visibleEventSequence = 0;
   let visibleEventGeneration = 0;
@@ -34856,6 +36206,11 @@ async function createInteractiveApplication(deps) {
     getLeaderArmed: () => leaderArmed,
     getShutdownArmed: () => shutdownArmed,
     isAwaitingApproval: () => overlayLifecycle?.getState() === "permission-confirm",
+    getPermissionInspection: () => {
+      if (overlayLifecycle === void 0 || overlayLifecycle === null) return "none";
+      if (!overlayLifecycle.canInspectMutation()) return "none";
+      return overlayLifecycle.isInspectingMutation() ? "open" : "closed";
+    },
     resolveVisibleEventSequence: (event) => visibleEventIngress.get(event)?.traceSequence ?? null,
     resolveStreamIngress: (event) => visibleEventIngress.get(event) ?? null,
     commitFrame: (reason) => shell.commitCurrentFrame(reason === "teardown" ? 300 : 3e4),
@@ -34964,7 +36319,7 @@ async function createInteractiveApplication(deps) {
     chat: deps.chat,
     chatPanel: {
       appendReplayBlock: (...args) => chatRenderer.mutate(() => chatPanel.appendReplayBlock(...args), "slash-output"),
-      appendUser: (text) => chatRenderer.mutate(() => chatPanel.appendUser(text), "user-submit"),
+      appendUser: (text, status) => chatRenderer.mutate(() => chatPanel.appendUser(text, status), "user-submit"),
       clearFoldOverrides: () => chatRenderer.mutate(() => chatPanel.clearFoldOverrides(), "output-detail")
     },
     beforeSemanticSubmit: () => chatRenderer.flush(),
@@ -35263,6 +36618,7 @@ async function createInteractiveApplication(deps) {
     cancelParkedCalls: (reason) => deps.toolRegistry?.cancelParkedCalls(reason),
     onShutdown: async () => {
       try {
+        if (dumpInputWedgeOnTerminate) process.off("SIGTERM", dumpInputWedgeOnTerminate);
         await deps.onShutdown();
       } finally {
         if (lease) await lease.close();
@@ -35381,7 +36737,7 @@ import { isAbsolute as isAbsolute6, relative as relative7, resolve as resolve6 }
 
 // src/tools/dispatch-scout-admission.ts
 init_esm_shims();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
 import { join as join10 } from "node:path";
 var MAX_SCOUT_PLAN_DEADLINE_MS = 36e5;
 function record(value) {
@@ -35433,7 +36789,7 @@ function loadVerifiedScoutSource(input) {
   if (!existsSync9(receiptPath)) throw new Error(`dispatch: Scout source receipt '${input.ref.runId}' is unavailable`);
   let receipt;
   try {
-    receipt = JSON.parse(readFileSync8(receiptPath, "utf8"));
+    receipt = JSON.parse(readFileSync9(receiptPath, "utf8"));
   } catch (error) {
     throw new Error(
       `dispatch: Scout source receipt is unreadable: ${error instanceof Error ? error.message : String(error)}`
@@ -35670,14 +37026,6 @@ function councilSettingsFromArgs(args, deps) {
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function reviewerTask(originalTask, builderRunId, cycle) {
-  return [
-    `Review the work of builder run ${builderRunId} (review cycle ${cycle}).`,
-    "The builder's final answer is provided as input data; verify it against the workspace, do not trust it blindly.",
-    "Original task the builder was given:",
-    originalTask
-  ].join("\n\n");
-}
 function reviewSettingsFromArgs(args) {
   const raw = args.review;
   if (raw === void 0 || raw === false) return { ok: true, review: void 0 };
@@ -36007,9 +37355,6 @@ function createDispatchAdmissionController(deps) {
       if (parsed.requests.length !== 1 || parsed.requests[0] === void 0) {
         return shapeRejection(args, REVIEW_SINGLE_TASK_MESSAGE);
       }
-      if (parsed.requests.some((request) => (request.resolvedVerification?.length ?? 0) > 0)) {
-        return shapeRejection(args, "verification_unsupported_for_mode: review requests cannot run host verification");
-      }
     }
     if (mode === "compete" && (parsed.requests.length !== 1 || parsed.requests[0] === void 0)) {
       return shapeRejection(args, COMPETE_SINGLE_TASK_MESSAGE);
@@ -36060,7 +37405,7 @@ function createDispatchAdmissionController(deps) {
               {
                 agentId: gateDeciderAgentId(reviewResult.review.reviewer),
                 executionRole: "reviewer",
-                task: reviewerTask(base.task, subject.runId, cycle),
+                task: renderDispatchReviewerTask(base.task, subject.runId, cycle, base.intent),
                 systemPrompt: REVIEWER_GATE_PROMPT,
                 autonomy: "read-only",
                 gate: { role: "reviewer", group: "plan-preview", cycle, subjects: [subject] },
@@ -36121,6 +37466,13 @@ function createDispatchAdmissionController(deps) {
               executionRole: "researcher",
               autonomy: "read-only",
               toolProfile: "council-read-only",
+              // The runner reuses this composed task from the resolved plan, so
+              // the approval artifact the plan hash binds shows the operator the
+              // exact ballot the member is asked to cast.
+              ...council.synthesis === "vote" ? {
+                task: renderCouncilVoteMemberTask(base.task),
+                resultContractOverride: { kind: "council-ballot" }
+              } : {},
               target: member.target,
               ...member.model ? { model: member.model } : {},
               ...member.thinking ? { thinkingLevel: member.thinking } : {},
@@ -36293,7 +37645,7 @@ function createDispatchTool(inputDeps, surfaceOptions = {}) {
   const admission = createDispatchAdmissionController(deps);
   let runnerPromise = null;
   const loadRunner = () => {
-    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-B7MTOVKL.js")))();
+    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-VVA4SRRH.js")))();
     return runnerPromise;
   };
   return {
@@ -36531,7 +37883,7 @@ function registerAllTools(registry, deps = {}) {
       ...builtin(
         lazyTool(
           monitorToolSurface,
-          async () => (await import("./monitor-TJ7AMTGB.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
+          async () => (await import("./monitor-MMVTJABD.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
         ),
         {
           path: "src/tools/monitor.ts",
@@ -36541,7 +37893,7 @@ function registerAllTools(registry, deps = {}) {
     });
     registry.register({
       ...builtin(
-        lazyTool(steerToolSurface, async () => (await import("./steer-GGWFUJUD.js")).createSteerTool({ dispatch })),
+        lazyTool(steerToolSurface, async () => (await import("./steer-CF5TDANS.js")).createSteerTool({ dispatch })),
         {
           path: "src/tools/steer.ts",
           scope: "core"
@@ -36688,7 +38040,7 @@ async function resolveApiKeyForTarget(target, providers, signal) {
   const resolved = await providers.auth.resolveForTarget(target, runtime, signal ? { signal } : void 0);
   return resolved.apiKey;
 }
-function createBackgroundMemoryModelClient(providers, settings, timeoutMs) {
+function createBackgroundMemoryModelClient(providers, settings, timeoutMs, bus) {
   const targetId = settings.background.target?.trim();
   const wireModelId = settings.background.model?.trim();
   if (!targetId || !wireModelId) return null;
@@ -36712,22 +38064,52 @@ function createBackgroundMemoryModelClient(providers, settings, timeoutMs) {
   const model = resolved.target.runtime.synthesizeModel(resolved.target.target, resolved.target.wireModelId, kbHit);
   const refined = refineRuntimeTargetWithModelHints(resolved.target, model, providers.knowledgeBase);
   applyModelCapabilityPatch(model, refined.capabilities);
+  const costProvenance = normalizeCostProvenance(refined.costProvenance);
+  const endpointKey = canonicalEndpointKey(refined.target);
   return {
-    async complete(request) {
-      const apiKey = targetRequiresAuth(refined.target, refined.runtime) ? (await providers.auth.resolveForTarget(refined.target, refined.runtime, { signal: request.signal })).apiKey : LOCAL_API_KEY_FALLBACK2;
-      return completeEngineText({
-        model,
-        systemPrompt: request.systemPrompt,
-        userPrompt: request.userPrompt,
-        maxTokens: request.maxTokens,
-        // Always off, never the operator's chat thinking level. A model that
-        // reasons anyway still works: `completeEngineText` keeps only text
-        // blocks, and the memory output budget leaves room for the preamble.
-        thinkingLevel: "off",
-        signal: request.signal,
-        timeoutMs,
-        ...apiKey === void 0 ? {} : { apiKey }
-      });
+    targetId,
+    wireModelId: refined.wireModelId,
+    endpointKey,
+    client: {
+      // Wrapped at the layer that knows a request left the process: the step
+      // holds endpoint capacity while it is out and publishes the cache
+      // disturbance even when a timeout means the usage sink never sees it.
+      complete: announceMemoryStepEndpoint({ bus, endpointKey, targetId }, async (request) => {
+        const apiKey = targetRequiresAuth(refined.target, refined.runtime) ? (await providers.auth.resolveForTarget(refined.target, refined.runtime, { signal: request.signal })).apiKey : LOCAL_API_KEY_FALLBACK2;
+        const startedAt = Date.now();
+        const completion = await completeEngineText({
+          model,
+          systemPrompt: request.systemPrompt,
+          userPrompt: request.userPrompt,
+          maxTokens: request.maxTokens,
+          // Always off, never the operator's chat thinking level. A model that
+          // reasons anyway still works: `completeEngineText` keeps only text
+          // blocks, and the memory output budget leaves room for the preamble.
+          thinkingLevel: "off",
+          signal: request.signal,
+          timeoutMs,
+          ...apiKey === void 0 ? {} : { apiKey }
+        });
+        return {
+          text: completion.text,
+          inputTokens: completion.inputTokens,
+          outputTokens: completion.outputTokens,
+          usage: {
+            targetId,
+            attributedModelId: refined.wireModelId,
+            input: completion.usage.input,
+            output: completion.usage.output,
+            cacheRead: completion.usage.cacheRead,
+            cacheWrite: completion.usage.cacheWrite,
+            reasoning: completion.usage.reasoning,
+            totalTokens: completion.usage.totalTokens,
+            costUsd: completion.usage.costUsd,
+            costProvenance,
+            durationMs: Date.now() - startedAt,
+            backend: completion.backend
+          }
+        };
+      })
     }
   };
 }
@@ -36798,7 +38180,7 @@ async function resolveCompactionModel(settings, providers) {
   const model = synthesizeOrchestratorModel(providers, target, wireModelId);
   if (!model) return null;
   const apiKey = await resolveApiKeyForTarget(target, providers);
-  const resolution = { model, targetId };
+  const resolution = { model, targetId, endpointKey: canonicalEndpointKey(target) };
   if (apiKey !== void 0) resolution.apiKey = apiKey;
   return resolution;
 }
@@ -36870,12 +38252,19 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   const activeLeafTurnId = session.tree(meta.id).leafId ?? void 0;
   const entries = filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId);
   if (entries.length === 0) return null;
-  const result = await compact({
-    entries,
-    model: resolved.model,
-    ...resolved.apiKey !== void 0 ? { apiKey: resolved.apiKey } : {},
-    ...instructions !== void 0 ? { instructions } : {}
-  });
+  const releaseEndpointSlot = resolved.endpointKey === null ? () => {
+  } : registerForegroundStream(resolved.endpointKey);
+  let result;
+  try {
+    result = await compact({
+      entries,
+      model: resolved.model,
+      ...resolved.apiKey !== void 0 ? { apiKey: resolved.apiKey } : {},
+      ...instructions !== void 0 ? { instructions } : {}
+    });
+  } finally {
+    releaseEndpointSlot();
+  }
   if (result.messagesSummarized === 0 || result.summary.length === 0) return null;
   const entry = {
     kind: "compactionSummary",
@@ -37244,6 +38633,40 @@ async function bootOrchestrator(options = {}) {
   let deferredWatchdogNoticeSink = null;
   const memoryTracePath = taskMemoryTracePath();
   const memoryTrace = memoryTracePath === null ? null : createTaskMemoryTrace(memoryTracePath);
+  let backgroundMemoryRoute = null;
+  const recordBackgroundMemoryUsage = (usage) => {
+    const meta = session?.current() ?? null;
+    try {
+      recordBackgroundMemoryStep({
+        usage,
+        stateDir: clioStateDir(),
+        sessionId: meta?.id ?? null,
+        // The identity the session ledger is filed under, so `usage report
+        // --repo` selects these rows with the same hash it selects ledgers with.
+        repoIdentity: meta ? meta.cwdHash || cwdHash(meta.cwd || process.cwd()) : null,
+        ...observability === void 0 ? {} : { observability }
+      });
+    } catch {
+    }
+  };
+  const proposeInjectedMemoryEntries = (entries) => {
+    const meta = session?.current() ?? null;
+    void proposeInjectedTaskMemory(clioDataDir(), {
+      sessionId: meta?.id ?? null,
+      cwd: meta?.cwd || process.cwd(),
+      entries
+    }).then((result2) => {
+      for (const error of result2.errors) {
+        process.stderr.write(`[clio:memory] proposed record not written for ${error}
+`);
+      }
+    }).catch((error) => {
+      process.stderr.write(
+        `[clio:memory] proposed records not written: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    });
+  };
   const memoryIntervention = createMemoryInterventionRegistration({
     bank: taskMemoryBank,
     telemetry: createTaskMemoryTelemetrySink(),
@@ -37258,8 +38681,21 @@ async function bootOrchestrator(options = {}) {
     },
     getModelClient: () => {
       const settings = effectiveSettingsForDispatch?.();
-      return settings === void 0 ? null : createBackgroundMemoryModelClient(providers, settings, settings.memory.intervention.timeoutMs);
-    }
+      backgroundMemoryRoute = settings === void 0 ? null : createBackgroundMemoryModelClient(providers, settings, settings.memory.intervention.timeoutMs, bus);
+      return backgroundMemoryRoute?.client ?? null;
+    },
+    // A single-slot local server serves one request at a time, so a memory step
+    // started while the operator's turn is streaming either waits behind it or
+    // makes the server swap the resident model out to answer. The chat loop
+    // registers its stream on the endpoint it streams against, so the two are
+    // compared by the same canonical key dispatch admission counts slots on.
+    backgroundEndpointBusy: () => {
+      const endpointKey = backgroundMemoryRoute?.endpointKey ?? null;
+      if (endpointKey === null) return false;
+      return (foregroundStreamUsage()[endpointKey] ?? 0) > 0;
+    },
+    onStepUsage: (usage) => recordBackgroundMemoryUsage(usage),
+    onInjectedEntries: (entries) => proposeInjectedMemoryEntries(entries)
   });
   middleware.registerHook(memoryIntervention);
   const unsubscribeMemoryLoop = bus.on(BusChannels.LoopBlocked, () => memoryIntervention.signalLoop());
@@ -37587,6 +39023,12 @@ async function bootOrchestrator(options = {}) {
     );
   }
   const chat = createChatLoop({
+    // The pre-warm holds one slot on its endpoint while it runs, so dispatch
+    // admission (#250) sees it exactly as it sees the orchestrator's own turn.
+    registerPrewarmEndpointSlot: (runtime) => {
+      const key = canonicalEndpointKey(runtime.runtimeResolution.target);
+      return key === null ? null : registerForegroundStream(key);
+    },
     getSettings: getCurrentSettings,
     providers,
     middleware,
@@ -37643,7 +39085,12 @@ async function bootOrchestrator(options = {}) {
       autoCompact: createProductionAutoCompact(session, getCurrentSettings, providers)
     } : {},
     toolRegistry,
-    hasAttachedDispatch: () => dispatchBackground.size() > 0
+    hasAttachedDispatch: () => dispatchBackground.size() > 0,
+    // The pre-warm buys latency for a person about to type the next turn. A
+    // headless `run` submits its one prompt immediately and an unattended boot
+    // never submits at all, so neither has latency to buy; the ACP surface has
+    // an operator on the other end of the client and keeps it.
+    isLatencySurface: () => interactive || acpMode
   });
   termination.onDrain(async () => {
     chat.dispose();
@@ -37846,7 +39293,11 @@ async function bootOrchestrator(options = {}) {
         lastDecision: memoryIntervention.lastDecision(),
         bank,
         activity: memoryIntervention.recentActivity(),
-        stepInFlight: memoryIntervention.stepInFlight()
+        stepInFlight: memoryIntervention.stepInFlight(),
+        // Folded from the telemetry ledger, which is durable across sessions,
+        // so `/memory` answers what the tier has cost since it was turned on
+        // rather than what it cost since this process started.
+        spend: readTaskMemorySpendSummary(clioStateDir())
       };
     },
     getTaskMemorySeedOffer,
@@ -38019,4 +39470,4 @@ export {
   resolveApiKeyForTarget,
   synthesizeOrchestratorModel
 };
-//# sourceMappingURL=orchestrator-WZYB54DM.js.map
+//# sourceMappingURL=orchestrator-ZKBPCHW6.js.map