@iowarp/clio-coder 0.4.4 → 0.4.5

package/dist/{orchestrator-J4BSH4WQ.js → orchestrator-N47O7SFD.js}

@@ -8,7 +8,7 @@ import {
   detectOverflowFromState,
   detectTerminalFailureFromState,
   estimatedUsageForInterruptedTurn,
-  expandInlineFileReferencesAsync,
+  explainInterruptedAssistant,
   extractText,
   extractThinking,
   extractUserText,
@@ -33,126 +33,98 @@ import {
   toolNamesFromAgentState,
   toolResultSummary,
   toolSignatureFromState
-} from "./chunk-YD5GIKET.js";
+} from "./chunk-UTUNT5QL.js";
 import {
   ShareDomainModule
-} from "./chunk-USR47QNF.js";
+} from "./chunk-UL36QJX6.js";
 import {
   bootstrapInputFromInitOptions,
   modelBootstrapGenerate,
   resolveBootstrapRoute
-} from "./chunk-N56KALIC.js";
-import "./chunk-MNJGS2IN.js";
+} from "./chunk-S32UQ5GL.js";
 import {
   DEFAULT_KEEP_RECENT_TOKENS,
   DEFAULT_RESERVE_TOKENS,
   buildEvictionFields,
   calculateContextTokens,
-  compactionCut,
   estimateTokens,
   findCutPoint,
   getLastAssistantUsage,
   planEviction,
   projectWorkingSet,
-  resolveWorkingSetPolicy,
-  selectVisibleEntries
-} from "./chunk-ZA4VCIGV.js";
+  resolveWorkingSetPolicy
+} from "./chunk-UUQ5G6EZ.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule,
   renderAgentCatalogSectionsFromSpecs
-} from "./chunk-YNFKXPEC.js";
+} from "./chunk-DIMRLNIC.js";
+import {
+  PROMPT_MANIFEST_VERSION,
+  appendPromptCompileRecord,
+  getPromptManifestFilePath,
+  readPromptCompileManifest,
+  readPromptCompileRecords
+} from "./chunk-5ZSZEYJK.js";
 import {
   recordFailedCompactionCalls
-} from "./chunk-FEAXX7B6.js";
+} from "./chunk-EHCPSZJF.js";
 import {
   describePanesLeftBehind,
   paneWatchDecision
-} from "./chunk-3EBYEESD.js";
+} from "./chunk-A46ILRS2.js";
 import {
   flushRawStdout,
   writeRawStdout
-} from "./chunk-2VTFPG5O.js";
+} from "./chunk-7WLRF2U5.js";
 import {
   capturedHookSourcesFor
-} from "./chunk-SZAA6XDG.js";
+} from "./chunk-IFDRAD6F.js";
 import {
   LifecycleDomainModule,
   describeUpgradeNotice
-} from "./chunk-JQLNNIKT.js";
-import "./chunk-GWZNEVM2.js";
-import "./chunk-5ICU3EUH.js";
+} from "./chunk-R6MICQYU.js";
+import "./chunk-EWD5P3GK.js";
+import "./chunk-GVYWZNRK.js";
 import {
   ConfigDomainModule,
   createConfigDomainModule,
   loadDomains
-} from "./chunk-72YIHOZQ.js";
-import "./chunk-4WR7VSYB.js";
+} from "./chunk-ILJ7DWGE.js";
+import "./chunk-YYB3MC65.js";
 import {
   buildRecallFields,
   recallErrorMessage,
   recallParentTurnId,
   recallableRefListing,
   resolveRecall
-} from "./chunk-O5CVSAG5.js";
+} from "./chunk-ECOMVOHP.js";
 import {
+  compactionCut,
   foldWorkingSet,
-  isTurnStart
-} from "./chunk-GTUD2WMY.js";
+  isTurnStart,
+  selectVisibleEntries
+} from "./chunk-DBREN25X.js";
 import {
   compileScoutTransition
-} from "./chunk-S6PYF2XF.js";
+} from "./chunk-WFKDPU7U.js";
 import {
   monitorToolSurface
-} from "./chunk-LLXSDWXS.js";
+} from "./chunk-NF3BK5WR.js";
 import {
   ObservabilityDomainModule,
   recordBackgroundMemoryStep
-} from "./chunk-Y55JBDO5.js";
+} from "./chunk-FSTIBAGM.js";
 import {
   appendOutOfTurnUsageRow,
   readAccountabilitySummary
-} from "./chunk-JT2RFCC5.js";
+} from "./chunk-HR3HPQ76.js";
 import {
   steerToolSurface
-} from "./chunk-RAY4OVGZ.js";
+} from "./chunk-URBGEOH3.js";
 import {
   panesToolSurface
-} from "./chunk-3GY4F45V.js";
-import {
-  createContextDomainModule,
-  loadProjectClioMd
-} from "./chunk-IZXGRF7P.js";
-import "./chunk-R6Q67RJH.js";
-import {
-  SafetyDomainModule
-} from "./chunk-5636DCO5.js";
-import {
-  renderCodewikiDigest
-} from "./chunk-V6HJFQZE.js";
-import {
-  buildMemoryPromptSection,
-  canonicalMemoryRepositoryIdentity,
-  createTaskMemoryTrace,
-  describeTaskMemoryActivity,
-  formatTaskMemorySpend,
-  loadMemoryRecordsSync,
-  proposeInjectedTaskMemory,
-  proposeMemoryPromotion,
-  readTaskMemorySpendSummary,
-  renderTaskMemoryHandoffSource,
-  seedTaskMemoryFromNewestHandoff,
-  taskMemoryBankSize,
-  taskMemoryHandoffSeedOffer,
-  taskMemoryTracePath
-} from "./chunk-EL24TAU4.js";
-import {
-  listWikiPages,
-  wikiCompleteness,
-  wikiStaleness,
-  wikiStalenessAsync
-} from "./chunk-ELZVTCGV.js";
-import "./chunk-MXHC5QYU.js";
+} from "./chunk-NC4KV7EL.js";
 import {
   BUILTIN_SLASH_COMMANDS,
   COMPLETION_SLOT_NAMES,
@@ -164,18 +136,17 @@ import {
   completeArgs,
   createWorkerStream,
   dispatchSlashCommand,
-  formatUserTaskHandoff,
   isWorkerShareNote,
   parseSlashCommand,
   renderArgsSpec,
   workerAskedByModel,
   workerReceiptSummary,
   workerTargetLabel
-} from "./chunk-FFUPXJC4.js";
+} from "./chunk-KDWLXVMN.js";
 import {
   boundSettledText
-} from "./chunk-XXYSBZIQ.js";
-import "./chunk-35MSIRKH.js";
+} from "./chunk-O2RQ7LCK.js";
+import "./chunk-QUIJZSDW.js";
 import {
   classifyLibraryRequirements,
   createResourcesDomainModule,
@@ -186,16 +157,120 @@ import {
   libraryEntryRef,
   libraryInstallPath,
   planLibraryInstall
-} from "./chunk-RQCKCSRL.js";
+} from "./chunk-U7VQ4NI4.js";
 import {
   AgentsDomainModule
-} from "./chunk-RZDWV63N.js";
-import "./chunk-7UGL4MB5.js";
-import "./chunk-DR52UMZW.js";
+} from "./chunk-NY6IWDVU.js";
+import "./chunk-EQEJJ53P.js";
+import "./chunk-3UW3KU4A.js";
 import {
-  createUserTasksStore
-} from "./chunk-EXLD33WO.js";
-import "./chunk-YAKGTXEV.js";
+  createUserTasksStore,
+  formatUserTaskHandoff
+} from "./chunk-VLPTKCKT.js";
+import "./chunk-QRFXEO6Y.js";
+import {
+  ToolchainDomainModule
+} from "./chunk-32KJPXAM.js";
+import "./chunk-K6RDB7IA.js";
+import {
+  ensureClioState,
+  takeUpgradeNotice
+} from "./chunk-E3BQTQUP.js";
+import "./chunk-T334FW2H.js";
+import "./chunk-LZBMXNLP.js";
+import {
+  MARKETPLACE_UNCONFIGURED,
+  discoverMarketplaceSkills,
+  installSkill,
+  modelVisibleSkills
+} from "./chunk-T7FDXNRU.js";
+import "./chunk-DNCE23JJ.js";
+import "./chunk-U7H5WRG5.js";
+import "./chunk-5GZICIYO.js";
+import "./chunk-MC3JSVR6.js";
+import {
+  INHERITED_PROJECT_CONTEXT,
+  InteropDomainModule,
+  delegationEntryForKind,
+  renderProposalEntry
+} from "./chunk-6SYEGZI3.js";
+import "./chunk-T53XI6I7.js";
+import {
+  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,
+  bashExecutionEntryInput,
+  brandMark,
+  buildHint,
+  buildResponsiveHint,
+  clioError,
+  clioTheme,
+  collapseHomePath,
+  createAgentProgress,
+  createKeybindingManager,
+  createProcessInteractiveShell,
+  detectPlatformKeybindingWarnings,
+  detectTerminalKeySupport,
+  diagnosticSeverityToken,
+  dotSep,
+  fgSequence,
+  fitHintEntries,
+  fitUnits,
+  formatCompactMs,
+  formatContextPercent,
+  formatInvalidKeybindingNotice,
+  formatPlatformKeybindingNotice,
+  formatRuntimeResolutionDiagnostic,
+  formatTargetLabel,
+  frame,
+  fuzzyFilter,
+  getActiveRenderTrace,
+  getKeybindings,
+  innerDivider,
+  isClioToken,
+  isKeyRelease,
+  joinChips,
+  joinSections,
+  listGroupHeader,
+  markdownTheme,
+  matchesKey,
+  padAnsi,
+  paintHex,
+  parseEditorBashCommand,
+  permissionHintEntries,
+  rule,
+  screenTitle,
+  sectionTag,
+  selectListTheme,
+  showClioOverlayFrame,
+  spinnerFrame,
+  stripTerminalSequences,
+  truncateToWidth,
+  unguardPastedEditorOperator,
+  validateKeybindings,
+  visibleWidth,
+  wrapTextWithAnsi,
+  writeInputWedgeDump
+} from "./chunk-7TKWWPD7.js";
+import {
+  getTerminationCoordinator
+} from "./chunk-BS4GAMUB.js";
 import {
   ACP_AGENT_META_KEY,
   ACP_MAX_CHUNK_BYTES,
@@ -210,54 +285,74 @@ import {
   COST_NOT_MEASURED,
   acpErrorMessage,
   aggregateCostAmounts,
+  buildMemoryPromptSection,
+  canonicalMemoryRepositoryIdentity,
   capacityLeaseUsage,
   costAggregateForAmount,
+  createContextDomainModule,
   createDispatchDomainModule,
   createDispatchRunEventRegistry,
   createRunReceiptQuality,
   createStdioServerTransport,
+  createTaskMemoryTrace,
+  describeTaskMemoryActivity,
   endpointCapacityUsage,
   evidenceDirectory,
   executeFleetRun,
   formatCostAggregate,
+  formatTaskMemorySpend,
   inspectEvidence,
   listEvidenceOverviews,
+  loadMemoryRecordsSync,
+  loadProjectClioMd,
+  newRunId,
   openLedger,
+  proposeInjectedTaskMemory,
+  proposeMemoryPromotion,
   protectedResidencyModels,
+  readTaskMemorySpendSummary,
   renderCostAggregate,
-  renderDispatchReviewerTask
-} from "./chunk-NRO2BJRH.js";
+  renderDispatchReviewerTask,
+  renderTaskMemoryHandoffSource,
+  seedTaskMemoryFromNewestHandoff,
+  taskMemoryBankSize,
+  taskMemoryHandoffSeedOffer,
+  taskMemoryTracePath
+} from "./chunk-SDWNDICN.js";
+import "./chunk-PECBKCDK.js";
 import {
   readGateDecisionArtifacts,
   readPendingGateDecisions
-} from "./chunk-NXIMQY5W.js";
-import "./chunk-XRZT5WY5.js";
+} from "./chunk-ODUTYZIU.js";
+import "./chunk-P5SC4DLJ.js";
 import {
   describeWriteBoundaryAttributionDowngrade,
   gitCheckoutRoot,
   isGitRepository,
   preflightWriteBoundaries,
   recoverCleanupReadyCompeteGroups
-} from "./chunk-QUFRYSWI.js";
+} from "./chunk-GNQRWTMY.js";
 import {
   bindExecutionPlanEndpoints,
   compileFleetExecutionPlan,
   requireAgentSteps
-} from "./chunk-LTIKRKFL.js";
+} from "./chunk-ONRTXOZY.js";
 import {
+  SafetyDomainModule,
   parseRigorOverride,
   resolveRigor
-} from "./chunk-ODGTEFFI.js";
+} from "./chunk-WLMSOT73.js";
 import {
   TRUST_STATUS_AXES,
   formatTrustSummaryLine,
   inspectRunReceiptTrustStatus,
   isReceiptIntegrity,
+  renderCodewikiDigest,
   retiredReceiptIntegrity,
   retiredReceiptIntegrityReason,
   trustStateWord,
   verifyReceiptIntegrity
-} from "./chunk-CUSRQKPU.js";
+} from "./chunk-6CDNRHWH.js";
 import {
   SessionDomainModule,
   addResponseModelIdObservationCount,
@@ -271,20 +366,30 @@ import {
   readAuditRows,
   responseModelIdObservationCountsLabel,
   responseModelIdObservationFromRecord
-} from "./chunk-6UINWWS6.js";
-import "./chunk-FTMGRKEF.js";
+} from "./chunk-F34AR6O3.js";
+import "./chunk-U44YYLVV.js";
 import {
   configureRunEventJournal
-} from "./chunk-VIA6RFQZ.js";
+} from "./chunk-UQIVHSE4.js";
+import {
+  wikiCompleteness,
+  wikiStaleness,
+  wikiStalenessAsync
+} from "./chunk-USZA7GWL.js";
+import {
+  listWikiPages
+} from "./chunk-LVFANMOH.js";
+import "./chunk-WTQGRBHV.js";
+import "./chunk-7WUZEB2M.js";
 import {
   filterEntriesToActivePath
-} from "./chunk-W6GROXXM.js";
+} from "./chunk-O5F25NIE.js";
 import {
   activeDecisionRefs,
   createDecisionBoardStore,
   decisionRationale,
   foldDecisionBoard
-} from "./chunk-I2DWJ4GM.js";
+} from "./chunk-5DDOTTG4.js";
 import {
   FLEET_COMMANDS_REMEDY,
   FleetCommandRegistryMissingError,
@@ -294,142 +399,39 @@ import {
   renderFleetPrompt,
   validateFleetCommands,
   validateFleetGraph
-} from "./chunk-OEJSLEPW.js";
-import "./chunk-RKKLTLYB.js";
+} from "./chunk-YEJIG7LN.js";
+import "./chunk-CXQ37WJH.js";
 import {
   discoverDeclaredChecks
-} from "./chunk-K6T2ZAMZ.js";
+} from "./chunk-HGSLRG33.js";
+import "./chunk-7YJWEF2L.js";
 import {
   shellQuote
-} from "./chunk-3UUXNFEX.js";
-import {
-  ToolchainDomainModule
-} from "./chunk-HRQMFLJP.js";
-import "./chunk-2ASED4PZ.js";
-import {
-  ensureClioState,
-  takeUpgradeNotice
-} from "./chunk-IGLP3ODT.js";
-import "./chunk-3M6DQK6S.js";
-import "./chunk-VKPAQYEB.js";
-import "./chunk-LCGCVYZ4.js";
-import {
-  MARKETPLACE_UNCONFIGURED,
-  discoverMarketplaceSkills,
-  installSkill,
-  modelVisibleSkills
-} from "./chunk-2ZSONWVL.js";
-import "./chunk-NDDGJUXD.js";
-import "./chunk-YECAMM3D.js";
-import "./chunk-V76WTFTW.js";
+} from "./chunk-SD7SHNDW.js";
+import "./chunk-T52TPHYC.js";
 import {
   foldPromptCacheTelemetry,
   hasPromptCacheTelemetry,
   uncachedPrefillTokens
-} from "./chunk-3DPEIQKN.js";
+} from "./chunk-QH3ZTUOA.js";
+import "./chunk-LQTKDAUO.js";
 import {
   EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP,
   ExtensionsDomainModule
-} from "./chunk-TQAHXW6Y.js";
-import "./chunk-5MEZN6CB.js";
-import "./chunk-D4CJV46V.js";
-import "./chunk-NEKRRTYW.js";
-import {
-  INHERITED_PROJECT_CONTEXT,
-  InteropDomainModule,
-  delegationEntryForKind,
-  renderProposalEntry
-} from "./chunk-JEIYHLOR.js";
-import "./chunk-I7XBWTYH.js";
-import {
-  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,
-  bashExecutionEntryInput,
-  brandMark,
-  buildHint,
-  buildResponsiveHint,
-  clioError,
-  clioTheme,
-  collapseHomePath,
-  createAgentProgress,
-  createKeybindingManager,
-  createProcessInteractiveShell,
-  detectPlatformKeybindingWarnings,
-  detectTerminalKeySupport,
-  diagnosticSeverityToken,
-  dotSep,
-  fgSequence,
-  fitHintEntries,
-  fitUnits,
-  formatCompactMs,
-  formatContextPercent,
-  formatInvalidKeybindingNotice,
-  formatPlatformKeybindingNotice,
-  formatRuntimeResolutionDiagnostic,
-  formatTargetLabel,
-  frame,
-  fuzzyFilter,
-  getActiveRenderTrace,
-  getKeybindings,
-  innerDivider,
-  isClioToken,
-  isKeyRelease,
-  joinChips,
-  joinSections,
-  listGroupHeader,
-  markdownTheme,
-  matchesKey,
-  padAnsi,
-  paintHex,
-  parseEditorBashCommand,
-  permissionHintEntries,
-  rule,
-  screenTitle,
-  sectionTag,
-  selectListTheme,
-  showClioOverlayFrame,
-  spinnerFrame,
-  stripTerminalSequences,
-  truncateToWidth,
-  unguardPastedEditorOperator,
-  validateKeybindings,
-  visibleWidth,
-  wrapTextWithAnsi,
-  writeInputWedgeDump
-} from "./chunk-25QBEXRS.js";
-import {
-  getTerminationCoordinator
-} from "./chunk-4O6MANBS.js";
-import "./chunk-JVCV3ICN.js";
+} from "./chunk-22PQ4TX4.js";
+import "./chunk-DZK63TZJ.js";
 import {
   emptyWorkspaceSnapshot,
   probeGitStatusAsync,
   probeWorkspaceAsync
-} from "./chunk-HVDIIIQW.js";
+} from "./chunk-DNHVRBH4.js";
 import {
   formatBootTrace,
   traceBoot
-} from "./chunk-ZTJUVLTU.js";
+} from "./chunk-FXFVDPWY.js";
 import {
   source_default
-} from "./chunk-JCI2ROMZ.js";
+} from "./chunk-3T4DXWP6.js";
 import {
   INTERACTIVE_LOOP_BLOCK_BUDGET,
   applyEditsToNormalizedContent,
@@ -450,10 +452,10 @@ import {
   resolveSessionTools,
   sanitizeLockedSynthesisMessage,
   stripBom
-} from "./chunk-36CT5VVL.js";
+} from "./chunk-U2JOLB7O.js";
 import {
   resolveFdBinary
-} from "./chunk-BMS5RKQY.js";
+} from "./chunk-JABWPKFY.js";
 import {
   MIDDLEWARE_HOOK_TEXT_MAX_CHARS,
   MiddlewareDomainModule,
@@ -475,20 +477,13 @@ import {
   openDetachedBatchViews,
   watchdogBriefing,
   writeMiddlewareDiagnosticToStderr
-} from "./chunk-XULDXHTN.js";
-import "./chunk-2CU2H6KE.js";
-import "./chunk-GX5WYQO4.js";
-import "./chunk-RXTN6AKH.js";
-import "./chunk-3UNOLWNZ.js";
-import "./chunk-5PSMVOLM.js";
-import {
-  TaskMemoryBank,
-  TaskMemoryEndpointBusyError,
-  createTaskMemoryTelemetrySink
-} from "./chunk-2WZ546HR.js";
-import {
-  escapeRegExp
-} from "./chunk-VG7TBQIY.js";
+} from "./chunk-DRD2A54W.js";
+import "./chunk-BBV5TKE6.js";
+import "./chunk-GXCCHKN6.js";
+import "./chunk-PWWSIB2A.js";
+import "./chunk-KTFSFCVN.js";
+import "./chunk-XCUDZQLX.js";
+import "./chunk-K2BLQC5E.js";
 import {
   ASK_USER_OTHER_LABEL,
   COUNCIL_JUDGE_PROMPT,
@@ -500,6 +495,8 @@ import {
   JUDGE_GATE_PROMPT,
   RESOLVED_DISPATCH_PLAN_ARGUMENT,
   REVIEWER_GATE_PROMPT,
+  TaskMemoryBank,
+  TaskMemoryEndpointBusyError,
   approvedRouteCandidates,
   askAxis,
   askUserExposure,
@@ -508,10 +505,12 @@ import {
   classifyDecisionPresentation,
   classifyResourceRead,
   createRegistry,
+  createTaskMemoryTelemetrySink,
   decisionActionClass,
   decisionFactsForAnswer,
   decisionFactsForPermission,
   describeDispatchPlan,
+  dispatchPlanTopology,
   dispatchRequestsFromArgs,
   finalizeAskUserInterviewForHost,
   formatBudgetPolicy,
@@ -530,96 +529,110 @@ import {
   timeoutMsArg,
   toolPresentationPolicy,
   withResolvedDispatchPlan
-} from "./chunk-75W7L2E2.js";
+} from "./chunk-TZ7MFRG4.js";
 import {
   DEFAULT_RECENT_ENTRY_LIMIT,
   assessFinishContract,
   recentEntries
-} from "./chunk-6QOTUPRG.js";
+} from "./chunk-KF6GFW6O.js";
 import {
-  defaultRoutingIntent,
-  sameRouteIdentity
-} from "./chunk-AUPNRN7C.js";
+  defaultRoutingIntent
+} from "./chunk-K2HL3GBL.js";
 import {
   createTaskBoardStore,
   foldSessionTaskHistory,
   foldTaskBoard,
   taskBoardCounts
-} from "./chunk-6PAZTBPA.js";
-import "./chunk-6Q3CYFD3.js";
+} from "./chunk-7HBHHVCK.js";
 import {
   describeCallTarget,
-  redactSecretString,
-  redactToolArgs,
   sanitizeCallTargetText,
   sanitizeMultilineDisplayText
-} from "./chunk-NEDJ26B5.js";
+} from "./chunk-2GPGAE5W.js";
+import "./chunk-SL2RDHKO.js";
 import {
+  expandInlineFileReferencesAsync
+} from "./chunk-YGDMBK7O.js";
+import {
+  escapeRegExp,
   resolveToCwd
-} from "./chunk-OQE5J4C6.js";
+} from "./chunk-V552WL53.js";
 import {
   sweepExpiredToolOffloads,
   toolResultPresentationPolicy,
   toolResultPresentationText
-} from "./chunk-NAI6ZFCY.js";
+} from "./chunk-RLTT5GVY.js";
 import {
   formatSize
-} from "./chunk-OZNBF4L3.js";
+} from "./chunk-KECNXMDE.js";
+import "./chunk-4SVIVOMC.js";
+import {
+  captureProjectSurface,
+  projectSurfaceTrustNotice
+} from "./chunk-NTK3WTHM.js";
+import "./chunk-WXA2CFJO.js";
 import {
   TOOL_PROFILE_NAMES
-} from "./chunk-QZWQA4DE.js";
+} from "./chunk-CBSKDFWL.js";
 import {
   agentRoleFactsResolver,
   gateDeciderAgentId,
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-H7IXIC72.js";
+} from "./chunk-LY4N4TTL.js";
 import {
+  RESULT_SUMMARY_MAX_BYTES_CEILING,
   isUserVisibleAgent,
   parseJsonObjectPayload,
   parseScoutResult,
   parseVerifierResult,
   resultContractSourceId
-} from "./chunk-KFV5L5SK.js";
+} from "./chunk-OQM5IVJY.js";
+import "./chunk-LUL5Z66S.js";
 import {
   toolMutationPaths
-} from "./chunk-NXYCB2VD.js";
-import "./chunk-ECH6PKUQ.js";
+} from "./chunk-M6TAYK66.js";
+import {
+  canonicalizeExistingPath
+} from "./chunk-KQ6IDQIB.js";
 import {
   narrowDispatchIntentToReadOnly,
   normalizeDispatchIntent
-} from "./chunk-IRXAATOX.js";
-import "./chunk-BJVFZO5U.js";
-import "./chunk-DXKJURES.js";
-import "./chunk-HHV2GANA.js";
-import "./chunk-GYV6VZOC.js";
+} from "./chunk-L4N3DWNW.js";
+import "./chunk-WJIMKGD6.js";
+import "./chunk-MDU3C27C.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
 import {
   VERIFICATION_SCRIPT_FAMILY_HINT
-} from "./chunk-UL3WSD3F.js";
+} from "./chunk-M4KFUXS7.js";
 import {
   typebox_exports
-} from "./chunk-5B2AEOW5.js";
-import "./chunk-VAVR4IJY.js";
-import "./chunk-QSNYB6ZV.js";
-import "./chunk-4BJ5BYCE.js";
+} from "./chunk-GH5ZR6JP.js";
+import "./chunk-VQD7NH7Z.js";
+import "./chunk-O3VV6IVK.js";
 import {
   DEFAULT_AUTONOMY_LEVEL,
+  SKILL_CONTEXT_STATE,
   SKILL_SUGGESTION_PREFIX,
   armedSkillSurface,
   isSessionEntry,
   isSkillActivation,
+  latestSkillContextState,
+  mainSkillContextState,
   modelMayActivateSkills,
   skillActivationFromToolDetails,
+  skillContextContentHash,
   skillSurfaceLabels,
   skillSurfaceNames,
+  verifiedSkillContextCheckpoint,
   withModelSkillActivation
-} from "./chunk-54X7T7DK.js";
-import "./chunk-I5FWO7L5.js";
-import "./chunk-6XLNIQDB.js";
+} from "./chunk-5ZMXGW7P.js";
+import "./chunk-B6UM3OZC.js";
+import "./chunk-MYI32N4R.js";
 import {
   ToolNames
-} from "./chunk-4NSRCOYP.js";
-import "./chunk-QDC3K2U3.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   ProvidersDomainModule,
   applyModelCapabilityPatch,
@@ -653,8 +666,8 @@ import {
   thinkingLevelChoiceLabel,
   thinkingLevelFromChoiceLabel,
   withRunOverrides
-} from "./chunk-JSD46VO2.js";
-import "./chunk-CFGTUFWB.js";
+} from "./chunk-TEG3RYVZ.js";
+import "./chunk-MCJKEGHO.js";
 import {
   AutoCompactionTrigger,
   DEFAULT_COMPACTION_THRESHOLD,
@@ -674,11 +687,8 @@ import {
   reconcileSnapshot,
   shouldCompact,
   snapshotInputTokens
-} from "./chunk-NZMNUPZZ.js";
-import "./chunk-2JH2WHGE.js";
-import {
-  interopAgentKind
-} from "./chunk-KXDSS5WJ.js";
+} from "./chunk-77CZRFTE.js";
+import "./chunk-J2FYEQ5L.js";
 import {
   SETTINGS_V1_PATH_MOVES,
   bindAgentProfileInSettings,
@@ -688,8 +698,11 @@ import {
   setFleetProfileInSettings,
   updateSettings,
   useTargetInSettings
-} from "./chunk-GHS5EBTQ.js";
-import "./chunk-D7E7WCDF.js";
+} from "./chunk-FKIOX6DS.js";
+import "./chunk-DVNAPPXU.js";
+import {
+  interopAgentKind
+} from "./chunk-5CY4Q6QI.js";
 import {
   atomicWrite,
   cwdHash,
@@ -697,88 +710,92 @@ import {
   readSessionTailTurns,
   sessionCurrentPath,
   sessionPaths
-} from "./chunk-HAXOFFRH.js";
-import "./chunk-R346GLFC.js";
-import "./chunk-BTK3SSSK.js";
+} from "./chunk-FQOOGXBH.js";
+import "./chunk-UHW5V7HC.js";
+import "./chunk-KMF54VH3.js";
 import {
   combineBashOutput,
   runBashCommand
-} from "./chunk-W54I7H25.js";
+} from "./chunk-5A6XR3RJ.js";
+import {
+  redactSecretString,
+  redactToolArgs
+} from "./chunk-EFSEIZE6.js";
 import {
   getSharedBus
-} from "./chunk-PMZVFWSR.js";
+} from "./chunk-B5ZTR6KZ.js";
 import {
   BusChannels,
   isRunAbortedPayload
-} from "./chunk-F4EKGO4N.js";
+} from "./chunk-HL26ADLH.js";
 import {
   incompleteInstallationAdvice
-} from "./chunk-65DEGPJ6.js";
-import "./chunk-BWH6N36D.js";
-import "./chunk-UUVG37B4.js";
+} from "./chunk-3A3CUMKA.js";
+import "./chunk-VHKTOLEW.js";
+import "./chunk-KPRLAMP4.js";
 import {
   readCodewiki,
   readCodewikiAsync
-} from "./chunk-LBMZMYH2.js";
-import "./chunk-XAKHZX5N.js";
+} from "./chunk-W2RJEH6Q.js";
+import "./chunk-CVDAFGPW.js";
 import {
   enumerateWorkspaceFilesAsync
-} from "./chunk-33YXPOE3.js";
-import "./chunk-7CR24IG7.js";
+} from "./chunk-PPEZJWUG.js";
+import "./chunk-WDV62RKY.js";
 import {
   getVersionInfo
-} from "./chunk-XPLRXC72.js";
+} from "./chunk-GD55RTIW.js";
 import {
   readClioVersion,
   readPiMonoVersion
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   VALID_THINKING_LEVELS,
   formatContextWindowSlots,
   registerBuiltinRuntimes
-} from "./chunk-6OSVSQL5.js";
+} from "./chunk-ICO4TQ2F.js";
 import {
   ACTIVE_ROUTING_POSTURES,
   ACTIVE_ROUTING_ROLES,
   DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS,
   DEFAULT_SETTINGS,
   THINKING_LEVELS
-} from "./chunk-UXCU4E3T.js";
-import "./chunk-LL4KHSZI.js";
+} from "./chunk-SE4ZKILO.js";
+import "./chunk-U2MSJ57E.js";
 import {
   configureGuardrails,
   guardrailValuesFromSettings
-} from "./chunk-S66XZJOF.js";
-import "./chunk-TOIVGRUX.js";
+} from "./chunk-C27U2TYG.js";
+import "./chunk-GJ24ODAX.js";
 import {
   setCommitDecisionRefsProvider,
   setGitCommitAttributionEnabled
-} from "./chunk-U6TMQNSI.js";
+} from "./chunk-LTR5QCLS.js";
 import {
   MAX_TIMER_DELAY_MS,
   rawDurationMs
-} from "./chunk-EBY63B7G.js";
-import "./chunk-6EJMN2Y3.js";
+} from "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
 import {
   resolveProviderReference
-} from "./chunk-26QSH3EJ.js";
+} from "./chunk-HHVJNVUJ.js";
 import {
   targetRequiresAuth
-} from "./chunk-ID64D7PE.js";
-import "./chunk-336NSSKI.js";
-import "./chunk-IKCO5N3L.js";
-import "./chunk-3I7MS7N2.js";
-import "./chunk-APJ265NV.js";
+} from "./chunk-HXHFDHB6.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-2QPI3TR3.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-B5GGDIHT.js";
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   getRuntimeRegistry
-} from "./chunk-NUGM5KR6.js";
+} from "./chunk-SRCEQKQS.js";
 import {
   AGENT_ROLE_TOOLS_REQUIRED_REASON,
   supportsAgentRoleTools
-} from "./chunk-5OIVVPHF.js";
+} from "./chunk-TN5FW4XY.js";
 import {
   StringEnum,
   cleanupEngineSessionResources,
@@ -786,24 +803,24 @@ import {
   isEngineRetryableAssistantError,
   stream,
   streamSimple
-} from "./chunk-YPC6ZR5L.js";
-import "./chunk-YXLYO42X.js";
-import "./chunk-2LEAKD4C.js";
+} from "./chunk-5CMARGPF.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-CKK25WN3.js";
 import {
   clioConfigDir,
   clioDataDir,
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/entry/orchestrator.ts
 init_esm_shims();
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/cli/modes/print.ts
 init_esm_shims();
@@ -855,6 +872,7 @@ function resultFromEvent(event, current) {
   if (event.type !== "message_end") return current;
   const message = event.message;
   if (message?.role !== "assistant") return current;
+  current = { ...current, outputExhausted: message.stopReason === "length", sawTerminatingToolResult: false };
   const error = assistantError(message);
   if (error) return { ...current, text: "", error };
   const text = assistantText(message).trimEnd();
@@ -875,8 +893,14 @@ function recordToolEnd(stats, event) {
   stat3.count += 1;
   const durationMs = durationMsFromEvent(event);
   if (durationMs !== void 0) stat3.totalDurationMs += durationMs;
-  if (event.isError) stat3.errors += 1;
-  else stat3.ok += 1;
+  const outcome = event.outcome;
+  if (outcome === "blocked") stat3.blocked += 1;
+  else if (outcome === "error") stat3.errors += 1;
+  else if (outcome === "ok") stat3.ok += 1;
+  else if (outcome === void 0) {
+    if (event.isError) stat3.errors += 1;
+    else stat3.ok += 1;
+  }
   stats.toolStats.set(tool, stat3);
   if (tool === ToolNames.Context) {
     const rawTurnId = event.turnId;
@@ -943,6 +967,7 @@ async function recordHeadlessMainAgentReceipt(input) {
   const outcomeDetail = input.terminal.failureMessage;
   const ledger = openLedger();
   const envelope = ledger.create({
+    id: input.runId,
     agentId: "main-agent",
     executionRole: "builder",
     requestOrigin: "user",
@@ -1046,10 +1071,12 @@ function defaultShutdownHooks() {
   };
 }
 async function runHeadlessMainAgent(chat, options) {
+  const runId = newRunId();
   const mode = options.mode ?? "text";
   const jsonEvents = options.jsonEvents ?? "full";
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let result = {
+    outputExhausted: false,
     text: "",
     error: null,
     sawTerminatingToolResult: false,
@@ -1067,6 +1094,7 @@ async function runHeadlessMainAgent(chat, options) {
     if (sealed !== null) return sealed;
     const endedAt2 = (/* @__PURE__ */ new Date()).toISOString();
     sealed = recordHeadlessMainAgentReceipt({
+      runId,
       chat,
       task: options.prompt,
       startedAt,
@@ -1155,6 +1183,7 @@ async function runHeadlessMainAgent(chat, options) {
   try {
     if (mode === "json" && jsonEvents === "terminal") writeTerminalTurnStart();
     const submitOptions = {
+      hostRun: { runId, lineage: { parentRunId: null, rootRunId: runId, depth: 0, attempt: 0 } },
       ...options.images && options.images.length > 0 ? { images: options.images } : {},
       ...options.workingContextPaths && options.workingContextPaths.length > 0 ? { workingContextPaths: options.workingContextPaths } : {},
       ...options.pendingSkillRequests && options.pendingSkillRequests.length > 0 ? { pendingSkillRequests: options.pendingSkillRequests } : {}
@@ -1189,6 +1218,11 @@ async function runHeadlessMainAgent(chat, options) {
   } else if (result.error) {
     terminal = { exitCode: 1, outcome: "failed", status: "failed", failureMessage: result.error };
     stderrMessage = prefixHeadlessFailure(chat, result.error);
+  } else if (result.outputExhausted && !result.sawTerminatingToolResult) {
+    const failureMessage = "clio-coder run: output token limit reached (stopReason=length); generation incomplete. Consider resuming with a narrower task, lower reasoning effort, or a larger output budget.";
+    terminal = { exitCode: 1, outcome: "failed", status: "failed", failureMessage };
+    stderrMessage = failureMessage;
+    if (mode === "text" && result.text.length > 0) stdoutMessage = result.text;
   } else if (result.text.length === 0 && !result.sawTerminatingToolResult) {
     const failureMessage = result.lastNotice !== null ? `clio-coder run: no assistant response (${result.lastNotice})` : "clio-coder run: no assistant response";
     terminal = { exitCode: 1, outcome: "failed", status: "failed", failureMessage };
@@ -1213,7 +1247,8 @@ async function runHeadlessMainAgent(chat, options) {
   if (stderrMessage !== null) {
     process.stderr.write(`${stderrMessage}
 `);
-  } else if (stdoutMessage !== null) {
+  }
+  if (stdoutMessage !== null) {
     writeRawStdout(`${stdoutMessage}
 `);
   }
@@ -1870,6 +1905,41 @@ In addition to that carried-forward context, summarize ONLY the active-turn deta
 - what should happen next
 
 Do NOT answer the user. Do NOT summarize unrelated older history.`;
+function validateHistorySummary(text) {
+  const required = [
+    "## Goal",
+    "## Constraints & Preferences",
+    "## Progress",
+    "### Done",
+    "### In Progress",
+    "### Blocked",
+    "## Key Decisions",
+    "## Next Steps",
+    "## Critical Context"
+  ];
+  const headings = [];
+  let fence;
+  for (const line of text.split(/\r?\n/)) {
+    const fenceMatch = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (fenceMatch) {
+      const marker = fenceMatch[1] ?? "";
+      if (!fence) fence = { character: marker[0] ?? "", length: marker.length };
+      else if (marker[0] === fence.character && marker.length >= fence.length && !fenceMatch[2]?.trim()) fence = void 0;
+      continue;
+    }
+    if (fence) continue;
+    const heading = /^ {0,3}(#{2,3})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/.exec(line);
+    if (heading) {
+      const normalized = `${heading[1]} ${heading[2]}`;
+      if (required.includes(normalized)) headings.push(normalized);
+    }
+  }
+  if (fence || headings.length !== required.length || headings.some((heading, index) => heading !== required[index])) {
+    throw new Error(
+      "compaction returned an incomplete history checkpoint: required headings must appear in order outside code fences; checkpoint was not saved"
+    );
+  }
+}
 function buildUserMessage(text) {
   return {
     role: "user",
@@ -1901,6 +1971,90 @@ function findTurnStartForProtection(entries, entryIndex, startIndex) {
   }
   return -1;
 }
+function captureSkillContext(entries, selection) {
+  if (!selection || selection.unknown) return void 0;
+  const newestSelected = Math.max(
+    -1,
+    ...selection.activationRefs.map((ref) => entries.findIndex((entry) => entry.turnId === ref))
+  );
+  if (selection.activationRefs.length > 0 && entries.slice(newestSelected + 1).some((entry) => entry.kind === "skillActivation" && entry.activation.runId === void 0))
+    return void 0;
+  const skills = [];
+  for (const ref of selection.activationRefs) {
+    const matches = entries.filter((entry2) => entry2.turnId === ref);
+    const entry = matches[0];
+    if (matches.length !== 1 || entry?.kind !== "skillActivation") return void 0;
+    const activation = entry.activation;
+    if (activation.runId !== void 0 || activation.triggeredBy !== "tool" || !activation.turnId || activation.drift === "mismatch")
+      return void 0;
+    if (entries.slice(entries.indexOf(entry) + 1).some(
+      (later) => later.kind === "skillActivation" && later.activation.runId === void 0 && later.activation.name === activation.name
+    ))
+      return void 0;
+    const request = entries.find((candidate) => candidate.turnId === activation.turnId);
+    if (request?.kind !== "message" || request.role !== "user") return void 0;
+    const start = entries.indexOf(request);
+    const next = entries.findIndex(
+      (candidate, index) => index > start && candidate.kind === "message" && candidate.role === "user"
+    );
+    const turn = entries.slice(start, next < 0 ? void 0 : next);
+    if (!turn.includes(entry)) return void 0;
+    const calls = turn.filter((candidate) => {
+      if (candidate.kind !== "message" || candidate.role !== "tool_call") return false;
+      const payload2 = payloadObject2(candidate.payload);
+      const args = payloadObject2(payload2?.args);
+      return payload2?.name === "context" && args?.scope === "skills" && args.name === activation.name;
+    });
+    if (calls.length !== 1) return void 0;
+    const call = calls[0];
+    if (call?.kind !== "message") return void 0;
+    const callId = payloadObject2(call.payload)?.toolCallId;
+    if (typeof callId !== "string" || !callId) return void 0;
+    const assistant = turn.find((candidate) => candidate.turnId === call.parentTurnId);
+    if (assistant?.kind !== "message" || assistant.role !== "assistant" || !contentBlocks2(assistant.payload).some(
+      (block) => block.type === "toolCall" && block.id === callId && block.name === "context" && JSON.stringify(block.arguments) === JSON.stringify(payloadObject2(call.payload)?.args)
+    ))
+      return void 0;
+    const results = entries.filter(
+      (candidate) => candidate.kind === "message" && candidate.role === "tool_result" && payloadObject2(candidate.payload)?.toolCallId === callId
+    );
+    const resultEntry = results[0];
+    if (results.length !== 1 || resultEntry?.kind !== "message" || !turn.includes(resultEntry) || resultEntry.parentTurnId !== call.turnId || entry.parentTurnId !== request.turnId)
+      return void 0;
+    const payload = payloadObject2(resultEntry.payload);
+    const result = payloadObject2(payload?.result);
+    const details = payloadObject2(result?.details);
+    const observation = payloadObject2(details?.observation);
+    const resultSummary = payloadObject2(payload?.resultSummary);
+    const summaryObservation = payloadObject2(resultSummary?.observation);
+    const sourceInfo = payloadObject2(details?.sourceInfo);
+    if (payload?.toolName !== "context" || payload.isError !== false || payload.outcome !== "ok" || details?.kind !== "ok" || observation?.truncated !== false || details.workingSet !== void 0 || details.contextCompaction !== void 0 || resultSummary?.truncated !== false || summaryObservation?.truncated === true || details.name !== activation.name || details.path !== activation.filePath || details.hash !== activation.hash || details.source !== activation.source || details.sourceOrigin !== activation.sourceOrigin || sourceInfo?.path !== activation.filePath || sourceInfo.scope !== details.scope || sourceInfo.source !== activation.sourceOrigin || details.drift !== void 0 && details.drift !== "match" || details.drift !== activation.drift || !Array.isArray(result?.content) || !result.content.every((block) => {
+      const obj = payloadObject2(block);
+      return obj?.type === "text" && typeof obj.text === "string";
+    }))
+      return void 0;
+    const content = result.content;
+    const text = content.map((block) => block.text).join("\n");
+    if (observation.shownBytes !== Buffer.byteLength(text, "utf8") || observation.totalBytes !== observation.shownBytes || resultSummary?.bytes !== observation.shownBytes)
+      return void 0;
+    const requestPayload = payloadObject2(request.payload);
+    const operatorText = requestPayload?.operatorText;
+    const requestText = typeof operatorText === "string" && operatorText.trim().length > 0 ? operatorText : requestPayload?.text;
+    if (typeof requestText !== "string") return void 0;
+    skills.push({
+      activationRef: ref,
+      requestRef: request.turnId,
+      callRef: call.turnId,
+      resultRef: resultEntry.turnId,
+      activation: structuredClone(activation),
+      requestText,
+      content: structuredClone(content),
+      contentHash: skillContextContentHash(content)
+    });
+  }
+  const checkpoint = { version: 1, skills };
+  return verifiedSkillContextCheckpoint(checkpoint) ? checkpoint : void 0;
+}
 function buildPreviousContextPrefix(previousContextText) {
   const trimmed = previousContextText.trim();
   return trimmed.length > 0 ? `<previous-context>
@@ -2027,20 +2181,23 @@ ${modified.join("\n")}
 
 ${sections.join("\n\n")}` : "";
 }
-function formatRecallableRefs(entries, firstKeptEntryIndex) {
+function formatRecallableRefs(entries, firstKeptEntryIndex, view) {
   const entryIndexes = /* @__PURE__ */ new Map();
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
     if (entry) entryIndexes.set(entry.turnId, index);
   }
-  const view = foldWorkingSet(entries);
   const evictedBeforeCut = new Map(
     [...view.evicted].filter(([ref]) => (entryIndexes.get(ref) ?? Number.POSITIVE_INFINITY) < firstKeptEntryIndex)
   );
   const listing = recallableRefListing(entries, { ...view, evicted: evictedBeforeCut });
-  if (listing.refs.length === 0) return "";
+  if (listing.refs.length === 0 && !entries.slice(0, firstKeptEntryIndex).some((entry) => entry.kind === "message" && entry.role === "tool_result"))
+    return "";
   const rows = [...listing.refs];
   if (listing.remaining > 0) rows.push(`and ${listing.remaining} more`);
+  rows.push(
+    'Preview only. Persisted original tool results removed by this summary are also recallable. Discover all active-path results with context(scope="recall", limit=8, offset=0), omitting ref; query filters path/tool/ref terms. Follow nextOffset, then recall the selected ref.'
+  );
   return `
 
 <recallable-refs>
@@ -2105,12 +2262,31 @@ async function runSummaryStream(input, userText, systemPrompt, maxTokens) {
     systemPrompt,
     messages: [buildUserMessage(userText)]
   };
+  const estimatedInput = estimateAgentContextTokens(context);
+  const contextWindow = input.model.contextWindow;
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+    throw new Error("compaction requires a positive finite model context window");
+  }
+  if (estimatedInput + maxTokens > contextWindow) {
+    throw new Error(
+      `compaction estimated input ${estimatedInput} tokens plus output ${maxTokens} tokens exceeds model context window ${contextWindow}; use a larger compaction model or reduce the working set`
+    );
+  }
+  input.signal?.throwIfAborted();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const started = performance.now();
   let usage;
   let reported = {};
   let outcome = "error";
   try {
+    if (input.summarize) {
+      const response = await input.summarize({ systemPrompt, userText, maxTokens });
+      usage = response.usage;
+      reported = retainReportedUsage(reported, usage);
+      input.signal?.throwIfAborted();
+      outcome = "success";
+      return { text: response.text.trim(), usage };
+    }
     const events = streamSimple(
       input.model,
       context,
@@ -2123,6 +2299,11 @@ async function runSummaryStream(input, userText, systemPrompt, maxTokens) {
       }
       if (event.type === "done") {
         usage = event.message.usage ?? usage;
+        reported = retainReportedUsage(reported, usage);
+        input.signal?.throwIfAborted();
+        if (event.reason === "length" || event.message.stopReason === "length") {
+          throw new Error("compaction summary reached the model output limit; incomplete checkpoint was not saved");
+        }
         outcome = "success";
         return { text: textFromAssistant(event.message).trim(), usage };
       }
@@ -2146,23 +2327,57 @@ async function runSummaryStream(input, userText, systemPrompt, maxTokens) {
 async function compact(input) {
   const reserveTokens = input.reserveTokens ?? DEFAULT_RESERVE_TOKENS;
   const keepRecentTokens = input.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS;
-  const prevCompactionIndex = findLatestCompactionIndex(input.entries);
+  const workingSet = foldWorkingSet(input.entries);
+  const entries = projectWorkingSet(input.entries, workingSet);
+  const prevCompactionIndex = findLatestCompactionIndex(entries);
   const boundaryStart = prevCompactionIndex + 1;
-  const protectedStart = findLatestSkillActivationProtectionStart(input.entries, boundaryStart);
+  const selection = input.skillContextState === null ? void 0 : input.skillContextState ?? latestSkillContextState(input.entries);
+  let skillContext = captureSkillContext(input.entries, selection);
+  const priorCheckpoint = entries[prevCompactionIndex];
+  const priorSkillContext = priorCheckpoint?.kind === "compactionSummary" && priorCheckpoint.skillContext !== void 0 && priorCheckpoint.skillContext.skills.length > 0 ? priorCheckpoint.skillContext : void 0;
+  if (priorSkillContext !== void 0 && !skillContext) {
+    throw new Error("cannot verify preserved skill context; retaining the existing checkpoint");
+  }
+  if (priorSkillContext !== void 0) {
+    if (!verifiedSkillContextCheckpoint(priorSkillContext)) throw new Error("invalid preserved skill checkpoint");
+    for (const previous of priorSkillContext.skills) {
+      const current = skillContext?.skills.find((skill) => skill.activationRef === previous.activationRef);
+      if (current && JSON.stringify(current) !== JSON.stringify(previous)) {
+        throw new Error("preserved skill context no longer matches its captured receipt");
+      }
+    }
+  }
+  if (skillContext && priorSkillContext !== void 0) {
+    skillContext = {
+      version: 1,
+      skills: skillContext.skills.map(
+        (skill) => structuredClone(
+          priorSkillContext.skills.find((previous) => previous.activationRef === skill.activationRef) ?? skill
+        )
+      )
+    };
+  }
+  const legacyPriorCheckpoint = priorCheckpoint?.kind === "compactionSummary" && priorCheckpoint.skillContext === void 0;
+  const protectedStart = skillContext ? null : findLatestSkillActivationProtectionStart(entries, legacyPriorCheckpoint ? 0 : boundaryStart);
   const usageStart = prevCompactionIndex >= 0 ? prevCompactionIndex : 0;
-  const usageEntries = input.entries.slice(usageStart);
+  const usageEntries = entries.slice(usageStart);
   const lastUsage = getLastAssistantUsage(usageEntries);
   const tokensBefore = calculateContextTokens(usageEntries, lastUsage);
-  const rawCut = findCutPoint(input.entries, keepRecentTokens, { startIndex: boundaryStart });
+  const rawCut = findCutPoint(entries, keepRecentTokens, { startIndex: boundaryStart });
   const cut = protectedStart !== null && rawCut.firstKeptEntryIndex > protectedStart ? { firstKeptEntryIndex: protectedStart, turnStartIndex: -1, isSplitTurn: false } : rawCut;
   const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
-  const pre = input.entries.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
-  const turnPrefix = cut.isSplitTurn ? input.entries.slice(Math.max(boundaryStart, cut.turnStartIndex), cut.firstKeptEntryIndex) : [];
-  const previousContextEntries = priorCompactionContextEntries(input.entries, prevCompactionIndex);
+  const pre = entries.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
+  const turnPrefix = cut.isSplitTurn ? entries.slice(Math.max(boundaryStart, cut.turnStartIndex), cut.firstKeptEntryIndex) : [];
+  const previousContextEntries = priorCompactionContextEntries(entries, prevCompactionIndex);
   const previousContextText = serializeConversation(previousContextEntries);
-  const fileOps = extractFileOps([...previousContextEntries, ...pre, ...turnPrefix]);
+  const fileOps = extractFileOps([
+    ...priorCompactionContextEntries(input.entries, prevCompactionIndex),
+    ...input.entries.slice(boundaryStart, cut.firstKeptEntryIndex)
+  ]);
   const firstKept = input.entries[cut.firstKeptEntryIndex] ?? null;
-  if (pre.length === 0 && turnPrefix.length === 0) {
+  const priorSuffix = previousContextEntries.slice(1);
+  const summarizePriorSuffix = pre.length === 0 && turnPrefix.length === 0 && firstKept !== null && cut.firstKeptEntryIndex >= boundaryStart && priorSuffix.some((entry) => entry.kind === "message" || entry.kind === "bashExecution");
+  if (pre.length === 0 && turnPrefix.length === 0 && !summarizePriorSuffix) {
     return {
       summary: "",
       firstKeptEntryIndex: cut.firstKeptEntryIndex,
@@ -2173,15 +2388,23 @@ async function compact(input) {
     };
   }
   const systemPrompt = input.systemPrompt ?? COMPACTION_SYSTEM_PROMPT;
-  const maxTokens = Math.max(1024, Math.floor(reserveTokens * 0.8));
+  if (!Number.isFinite(reserveTokens) || reserveTokens <= 0) {
+    throw new Error("compaction requires a positive finite reserve token budget");
+  }
+  if (!Number.isFinite(input.model.maxTokens) || input.model.maxTokens < 1) {
+    throw new Error("compaction requires a positive finite model output token limit");
+  }
+  const maxTokens = Math.min(Math.floor(input.model.maxTokens), Math.max(1024, Math.floor(reserveTokens * 0.8)));
   const summaryParts = [];
   let usage;
-  if (pre.length > 0) {
-    const conversationText = serializeConversation(pre);
-    const userText = buildUserText(conversationText, input.instructions, previousContextText);
+  if (pre.length > 0 || summarizePriorSuffix) {
+    const conversationText = serializeConversation(summarizePriorSuffix ? priorSuffix : pre);
+    const previousText = summarizePriorSuffix ? serializeConversation(previousContextEntries.slice(0, 1)) : previousContextText;
+    const userText = buildUserText(conversationText, input.instructions, previousText);
     const historySummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
     usage = addCompactionUsage(usage, historySummary.usage);
     if (historySummary.text.length === 0) throw new Error("compaction returned an empty history summary");
+    validateHistorySummary(historySummary.text);
     summaryParts.push(historySummary.text);
   }
   if (turnPrefix.length > 0) {
@@ -2194,18 +2417,37 @@ async function compact(input) {
 
 ${prefixSummary.text}`);
   }
+  let userContext = priorCheckpoint?.kind === "compactionSummary" ? priorCheckpoint.userContext : void 0;
+  let activeUserIndex = -1;
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry?.kind === "message" && entry.role === "user" && (input.preserveUserTurnId === void 0 || entry.turnId === input.preserveUserTurnId)) {
+      activeUserIndex = index;
+      break;
+    }
+  }
+  const activeUser = activeUserIndex >= 0 && activeUserIndex < cut.firstKeptEntryIndex ? entries[activeUserIndex] : void 0;
+  if (activeUser?.kind === "message" && activeUser.payload && typeof activeUser.payload === "object") {
+    const payload = activeUser.payload;
+    const operatorText = "operatorText" in payload ? payload.operatorText : void 0;
+    const text = typeof operatorText === "string" && operatorText.trim().length > 0 ? operatorText : "text" in payload && typeof payload.text === "string" ? payload.text : null;
+    if (text !== null) userContext = { turnId: activeUser.turnId, text };
+  }
   const summary = `${summaryParts.join("\n\n---\n\n").trim()}${formatFileOperations(fileOps)}${formatRecallableRefs(
     input.entries,
-    cut.firstKeptEntryIndex
+    cut.firstKeptEntryIndex,
+    workingSet
   )}`.trim();
   return {
     summary,
     firstKeptEntryIndex: cut.firstKeptEntryIndex,
     firstKeptTurnId: firstKept?.turnId ?? null,
     tokensBefore,
-    messagesSummarized: pre.length + turnPrefix.length,
+    messagesSummarized: pre.length + turnPrefix.length + (summarizePriorSuffix ? priorSuffix.length : 0),
     isSplitTurn: cut.isSplitTurn,
-    ...usage !== void 0 ? { usage } : {}
+    ...usage !== void 0 ? { usage } : {},
+    ...skillContext !== void 0 ? { skillContext } : {},
+    ...userContext !== void 0 ? { userContext } : {}
   };
 }
 function textFromAssistant(message) {
@@ -2445,6 +2687,7 @@ var ACP_ADMISSION_REASONS = /* @__PURE__ */ new Set([
   "model-not-configured",
   "chat-unsupported",
   "streaming-unsupported",
+  "context-window-exceeded",
   "admission-failed"
 ]);
 var ACP_ADMISSION_FALLBACK_REASON = "admission-failed";
@@ -4192,7 +4435,7 @@ async function serveClioAcpAgent(options) {
     }
     return promptResponse(active.stopReason, active);
   });
-  return await new Promise((resolve9) => {
+  return await new Promise((resolve10) => {
     options.transport.onClose(() => {
       permission.unregister();
       unsubscribeEventStream();
@@ -4200,14 +4443,14 @@ async function serveClioAcpAgent(options) {
       for (const session of sessions.values()) cancelSession(session, "ACP transport closed");
       const inFlight = promptSettled;
       if (inFlight === null) {
-        resolve9(0);
+        resolve10(0);
         return;
       }
-      const timer = setTimeout(() => resolve9(0), ACP_PROMPT_SETTLE_BOUND_MS);
+      const timer = setTimeout(() => resolve10(0), ACP_PROMPT_SETTLE_BOUND_MS);
       timer.unref?.();
       void inFlight.then(() => {
         clearTimeout(timer);
-        resolve9(0);
+        resolve10(0);
       });
     });
   });
@@ -4231,6 +4474,7 @@ function promptResponse(stopReason, active) {
 
 // src/interactive/chat-loop.ts
 init_esm_shims();
+import { AsyncLocalStorage } from "node:async_hooks";
 
 // src/domains/session/retry.ts
 init_esm_shims();
@@ -4840,6 +5084,7 @@ Extract the handoff record for that goal now.`
 
 // src/interactive/turn-context.ts
 init_esm_shims();
+import { createHash as createHash3 } from "node:crypto";
 
 // src/domains/session/compaction/mask-observations.ts
 init_esm_shims();
@@ -5035,105 +5280,12 @@ function maskStaleObservations(entries, excludeLastTurns) {
   };
 }
 
-// src/domains/session/prompt-manifest.ts
-init_esm_shims();
-import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname, join as join3 } from "node:path";
-var PROMPT_MANIFEST_VERSION = 2;
-var SHA256_HEX = /^[a-f0-9]{64}$/;
-function isCanonicalUtcTimestamp(value) {
-  if (typeof value !== "string") return false;
-  const timestamp = Date.parse(value);
-  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
-}
-function isRecord5(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-function isSha256(value) {
-  return typeof value === "string" && SHA256_HEX.test(value);
-}
-function isPromptManifestSection(value) {
-  return isRecord5(value) && typeof value.id === "string" && isNonNegativeInteger(value.tokenEstimate);
-}
-function isPromptManifestFragment(value) {
-  return isRecord5(value) && typeof value.id === "string" && typeof value.relPath === "string" && isSha256(value.contentHash) && typeof value.dynamic === "boolean";
-}
-function isProjectPreloadClass(value) {
-  if (!isRecord5(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 (!isRecord5(value)) return false;
-  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 = {
-    ...meta,
-    cwdHash: meta.cwdHash || cwdHash(meta.cwd || process.cwd())
-  };
-  if (stateDir !== void 0) {
-    return join3(stateDir, "sessions", safeMeta.cwdHash, safeMeta.id, "prompt-manifest.jsonl");
-  }
-  const paths = sessionPaths(safeMeta);
-  return join3(dirname(paths.current), "prompt-manifest.jsonl");
-}
-function appendPromptCompileRecord(meta, record2) {
-  try {
-    const file = getPromptManifestFilePath(meta);
-    appendFileSync(file, `${JSON.stringify(record2)}
-`, "utf8");
-  } catch {
-  }
-}
-function readPromptCompileManifest(meta, stateDir) {
-  const file = getPromptManifestFilePath(meta, stateDir);
-  try {
-    if (!existsSync3(file)) return { records: [], errors: [] };
-    const records = [];
-    const errors = [];
-    for (const [index, line] of readFileSync3(file, "utf8").split("\n").entries()) {
-      if (line.trim().length === 0) continue;
-      try {
-        const parsed = JSON.parse(line);
-        if (isSessionPromptCompileRecord(parsed)) {
-          records.push(parsed);
-        } else {
-          errors.push({ line: index + 1, message: "invalid prompt manifest record" });
-        }
-      } catch {
-        errors.push({ line: index + 1, message: "invalid JSON" });
-      }
-    }
-    return { records, errors };
-  } catch (err) {
-    return {
-      records: [],
-      errors: [{ line: null, message: err instanceof Error ? err.message : String(err) }]
-    };
-  }
-}
-function readPromptCompileRecords(meta) {
-  return readPromptCompileManifest(meta).records;
-}
-
 // src/interactive/model-session-replay.ts
 init_esm_shims();
 
 // src/interactive/chat-renderer.ts
 init_esm_shims();
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 
 // src/engine/messages.ts
 init_esm_shims();
@@ -5258,7 +5410,7 @@ init_esm_shims();
 // src/interactive/mutation-preview.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 var MUTATION_PREVIEW_VISIBLE_ROWS = 16;
 var MUTATION_PREVIEW_MAX_CHARS = 262144;
 function canonicalJson(value) {
@@ -5373,7 +5525,7 @@ function editPreview(facts, path2, edits, read) {
   }
 }
 function createMutationInspector(tool, args, facts, options = {}) {
-  const read = options.readFile ?? ((path2) => readFileSync4(path2, "utf8"));
+  const read = options.readFile ?? ((path2) => readFileSync3(path2, "utf8"));
   return () => {
     const current = mutationFacts(tool, args);
     if (current === null || current.digest !== facts.digest) {
@@ -5761,7 +5913,22 @@ function outcomeSummary(finished) {
   if (finished.toolName === "dispatch") {
     const receipts = numberField(details, "receiptCount");
     const failed = numberField(details, "failedCount") ?? 0;
-    if (receipts !== null) return `${receipts} task${receipts === 1 ? "" : "s"} -> ${receipts - failed} ok`;
+    if (receipts !== null) {
+      const runs = Array.isArray(details?.runs) ? details.runs.slice(0, receipts) : [];
+      const qualityCounts = /* @__PURE__ */ new Map();
+      for (const run of runs) {
+        const trust = isPlainObject(run) && isPlainObject(run.trust) ? run.trust : null;
+        const axes = isPlainObject(trust?.axes) ? trust.axes : null;
+        const word = trustStateWord("validationGrounding", stringField2(axes, "validationGrounding") ?? "unknown");
+        qualityCounts.set(word, (qualityCounts.get(word) ?? 0) + 1);
+      }
+      if (runs.length < receipts) {
+        const unknown = trustStateWord("validationGrounding", "unknown");
+        qualityCounts.set(unknown, (qualityCounts.get(unknown) ?? 0) + receipts - runs.length);
+      }
+      const quality = [...qualityCounts].map(([word, count2]) => `${count2} ${word}`).join(", ");
+      return `${receipts} task${receipts === 1 ? "" : "s"} -> ${receipts - failed} execution ok${failed > 0 ? `, ${failed} execution failed` : ""}${quality ? `; quality: ${quality}` : ""}`;
+    }
     return null;
   }
   if (finished.toolName === "tasks") {
@@ -6922,19 +7089,19 @@ function toggledFold(effective) {
 
 // src/interactive/worker-receipts.ts
 init_esm_shims();
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
 
 // src/interactive/view/artifacts.ts
 init_esm_shims();
-import { createReadStream, readFileSync as readFileSync5, statSync } from "node:fs";
+import { createReadStream, readFileSync as readFileSync4, statSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
-import { basename, isAbsolute as isAbsolute4, join as join4, relative as relative4, resolve as resolve3, sep } from "node:path";
+import { basename, isAbsolute as isAbsolute4, join as join3, relative as relative4, resolve as resolve3, sep } from "node:path";
 
 // src/domains/session/session-artifacts.ts
 init_esm_shims();
 import { isAbsolute as isAbsolute3, relative as relative2, resolve as resolve2 } from "node:path";
-function isRecord6(value) {
+function isRecord5(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isSessionArtifactTool(value) {
@@ -6956,15 +7123,15 @@ function foldSessionArtifacts(entries, options = {}) {
   const writeCounts = /* @__PURE__ */ new Map();
   let writeIndex = 0;
   for (const raw of entries) {
-    if (!isRecord6(raw) || raw.kind !== "message" || raw.role !== "tool_result") continue;
+    if (!isRecord5(raw) || raw.kind !== "message" || raw.role !== "tool_result") continue;
     if (typeof raw.turnId !== "string" || typeof raw.timestamp !== "string") continue;
     const payload = raw.payload;
-    if (!isRecord6(payload) || !isSessionArtifactTool(payload.toolName)) continue;
+    if (!isRecord5(payload) || !isSessionArtifactTool(payload.toolName)) continue;
     if (payload.isError === true || payload.outcome === "error" || payload.outcome === "blocked" || payload.outcome === "aborted" || payload.outcome === "orphaned") {
       continue;
     }
     const result = payload.result;
-    if (!isRecord6(result) || !isRecord6(result.details) || !Array.isArray(result.details.paths)) continue;
+    if (!isRecord5(result) || !isRecord5(result.details) || !Array.isArray(result.details.paths)) continue;
     const artifactKind = payload.toolName === "artifact" && isSessionArtifactKind(result.details.kind) ? result.details.kind : void 0;
     const pathsSeenInResult = /* @__PURE__ */ new Set();
     for (const recordedPath of result.details.paths) {
@@ -7783,7 +7950,16 @@ function renderTaskIslandRow(row2, width) {
   );
   const telemetry = row2.retry ? `  ${theme6.fg("warning", `attempt ${row2.retry.attempt}`)}${dot}${theme6.fg("muted", retryCountdown(row2.retry))}` : `  ${up}${dot}${down}${dot}${theme6.fg("muted", cost)}`;
   const task = row2.taskSummary ? `  ${theme6.fg("muted", truncateToWidth(row2.taskSummary, Math.max(1, width - 2), "\u2026", false))}` : null;
-  return [padAnsi(line1, width), ...task ? [padAnsi(task, width)] : [], padAnsi(telemetry, width)];
+  const quality = isTerminalStatus(row2.status) ? wrapTextWithAnsi(
+    `  quality: ${trustStateWord("validationGrounding", row2.trust?.axes.validationGrounding ?? "unknown")}`,
+    width
+  ) : [];
+  return [
+    padAnsi(line1, width),
+    ...quality.map((line) => padAnsi(theme6.fg("muted", line), width)),
+    ...task ? [padAnsi(task, width)] : [],
+    padAnsi(telemetry, width)
+  ];
 }
 function councilMemberView(row2, council) {
   const presentation = dispatchStatusPresentation(row2.status, {
@@ -9526,20 +9702,20 @@ function activityQuadrant(facts, options = {}) {
   rows.push(kv("tools", meaningfulToolTally(facts.toolTally)));
   return dashboardBlock(theme6, "Activity", rows);
 }
-function zipColumns2(left, right, leftWidth, rightWidth, sep3) {
+function zipColumns2(left, right, leftWidth, rightWidth, sep4) {
   const rowCount = Math.max(left.length, right.length);
   const lines = [];
   for (let i = 0; i < rowCount; i += 1) {
-    lines.push(`${cell(left[i] ?? "", leftWidth)}${sep3}${cell(right[i] ?? "", rightWidth)}`);
+    lines.push(`${cell(left[i] ?? "", leftWidth)}${sep4}${cell(right[i] ?? "", rightWidth)}`);
   }
   return lines;
 }
-function zipColumnBlocks(blocks, widths, sep3) {
+function zipColumnBlocks(blocks, widths, sep4) {
   const rowCount = blocks.reduce((max, block) => Math.max(max, block.length), 0);
   const lines = [];
   for (let row2 = 0; row2 < rowCount; row2 += 1) {
     const cells = blocks.map((block, index) => cell(block[row2] ?? "", widths[index] ?? 0));
-    lines.push(cells.join(sep3));
+    lines.push(cells.join(sep4));
   }
   return lines;
 }
@@ -9801,13 +9977,13 @@ var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{
 function isIso8601(value) {
   return typeof value === "string" && ISO_8601_REGEX.test(value) && !Number.isNaN(Date.parse(value));
 }
-function isRecord7(value) {
+function isRecord6(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
-function isNonNegativeInteger2(value) {
+function isNonNegativeInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
 function isNonNegativeFiniteNumber(value) {
@@ -9864,23 +10040,23 @@ function maybeSizeBytes(path2) {
 }
 function sessionCurrentPath2(stateDir, meta) {
   if (!meta) return void 0;
-  return join4(stateDir, "sessions", meta.cwdHash, meta.id, "current.jsonl");
+  return join3(stateDir, "sessions", meta.cwdHash, meta.id, "current.jsonl");
 }
 function protectedArtifactPath(path2) {
   return isAbsolute4(path2) ? path2 : void 0;
 }
 function receiptFilePath(stateDir, runId) {
-  return join4(stateDir, "receipts", `${runId}.json`);
+  return join3(stateDir, "receipts", `${runId}.json`);
 }
 function runLedgerPath(stateDir) {
-  return join4(stateDir, "runs.json");
+  return join3(stateDir, "runs.json");
 }
 function readRunLedger(stateDir) {
   try {
-    const raw = readFileSync5(runLedgerPath(stateDir), "utf8").trim();
+    const raw = readFileSync4(runLedgerPath(stateDir), "utf8").trim();
     if (raw.length === 0) return [];
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed.filter(isRecord7) : [];
+    return Array.isArray(parsed) ? parsed.filter(isRecord6) : [];
   } catch {
     return [];
   }
@@ -9902,14 +10078,14 @@ function validateToolStats(value) {
   }
   for (let i = 0; i < value.length; i++) {
     const entry = value[i];
-    if (!isRecord7(entry)) {
+    if (!isRecord6(entry)) {
       return { ok: false, reason: `toolStats[${i}] not an object` };
     }
     if (!isNonEmptyString(entry.tool)) {
       return { ok: false, reason: `toolStats[${i}].tool invalid: ${String(entry.tool)}` };
     }
     for (const key of ["count", "ok", "errors", "blocked"]) {
-      if (!isNonNegativeInteger2(entry[key])) {
+      if (!isNonNegativeInteger(entry[key])) {
         return { ok: false, reason: `toolStats[${i}].${key} invalid: ${String(entry[key])}` };
       }
     }
@@ -9921,7 +10097,7 @@ function validateToolStats(value) {
 }
 function receiptTrustDetail(stateDir, runId) {
   try {
-    const receipt = JSON.parse(readFileSync5(receiptFilePath(stateDir, runId), "utf8"));
+    const receipt = JSON.parse(readFileSync4(receiptFilePath(stateDir, runId), "utf8"));
     const ledger = readRunEnvelope(stateDir, runId);
     return formatTrustSummaryLine(inspectRunReceiptTrustStatus(receipt, ledger.ok ? ledger.envelope : null).status);
   } catch {
@@ -9939,7 +10115,7 @@ function verifyReceiptFile(stateDir, runId) {
   const target = receiptFilePath(stateDir, runId);
   let raw;
   try {
-    raw = readFileSync5(target, "utf8");
+    raw = readFileSync4(target, "utf8");
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") return { ok: false, reason: "receipt file not found" };
@@ -9951,7 +10127,7 @@ function verifyReceiptFile(stateDir, runId) {
   } catch (err) {
     return { ok: false, reason: `invalid json: ${err.message}` };
   }
-  if (!isRecord7(parsed)) {
+  if (!isRecord6(parsed)) {
     return { ok: false, reason: "receipt is not an object" };
   }
   const r = parsed;
@@ -10051,7 +10227,7 @@ var RECEIPT_FILE_FAILURE = /^(?:receipt file not found|read error:)/u;
 var RECEIPT_CONTRACT_FAILURE = /^(?:invalid json:|receipt is not an object|missing field:|runId invalid:|runId mismatch:|agentId invalid:|task invalid:|targetId invalid:|wireModelId invalid:|runtimeId invalid:|runtimeKind invalid:|exitCode out of range:|tokenCount out of range:|inputTokenCount out of range:|outputTokenCount out of range:|cacheReadTokenCount out of range:|cacheWriteTokenCount out of range:|costUsd out of range:|reasoningTokenCount out of range:|startedAt not ISO-8601:|endedAt not ISO-8601:|clioCoderVersion empty|piMonoVersion invalid:|platform invalid:|nodeVersion invalid:|toolCalls out of range:|toolStats\[|compiledPromptHash invalid:|staticCompositionHash invalid:|sessionId invalid:|integrity invalid|execution role invalid|routing intent invalid|route decision invalid)/u;
 var LEDGER_FAILURE = /^(?:run ledger not found|run not found in ledger|ledger mismatch:)/u;
 function receiptIntegrityDigest(value) {
-  if (!isRecord7(value) || value.algorithm !== "sha256" || !isNonEmptyString(value.digest)) return null;
+  if (!isRecord6(value) || value.algorithm !== "sha256" || !isNonEmptyString(value.digest)) return null;
   return `sha256:${value.digest}`;
 }
 function trustCheckEvidence(status, axis) {
@@ -10077,7 +10253,7 @@ function verifyReceiptFileReport(stateDir, runId) {
   const result = verifyReceiptFile(stateDir, runId);
   let receipt = null;
   try {
-    receipt = JSON.parse(readFileSync5(receiptPath, "utf8"));
+    receipt = JSON.parse(readFileSync4(receiptPath, "utf8"));
   } catch {
   }
   const sealedDigest = receiptIntegrityDigest(receipt?.integrity);
@@ -10386,17 +10562,17 @@ var ReceiptArtifactProvider = class {
   }
 };
 function resultText3(result) {
-  if (!isRecord7(result)) return "";
+  if (!isRecord6(result)) return "";
   if (result.kind === "ok" && typeof result.output === "string") return result.output;
   if (result.kind === "error" && typeof result.message === "string") return result.message;
   return "";
 }
 function resultDetails(result) {
-  return isRecord7(result) && isRecord7(result.details) ? result.details : null;
+  return isRecord6(result) && isRecord6(result.details) ? result.details : null;
 }
 function messagePayload(entry) {
   if (entry.kind !== "message") return null;
-  return isRecord7(entry.payload) ? entry.payload : null;
+  return isRecord6(entry.payload) ? entry.payload : null;
 }
 function toolNameFor(entry) {
   const payload = messagePayload(entry);
@@ -10422,7 +10598,7 @@ function dispatchResultForRun(entries, runId) {
     const details = resultDetails(payload.result);
     const detailRunId = details?.runId;
     const runIds = details?.runIds;
-    const matches = detailRunId === runId || Array.isArray(runIds) && runIds.some((item) => item === runId) || Array.isArray(details?.runs) && details.runs.some((item) => isRecord7(item) && item.runId === runId);
+    const matches = detailRunId === runId || Array.isArray(runIds) && runIds.some((item) => item === runId) || Array.isArray(details?.runs) && details.runs.some((item) => isRecord6(item) && item.runId === runId);
     if (!matches) continue;
     const text = resultText3(payload.result);
     if (text.length > 0) return text;
@@ -10989,7 +11165,7 @@ function auditRowPayload(row2) {
 }
 function auditReadErrorsArtifact(stateDir, errors) {
   if (errors.length === 0) return null;
-  const path2 = join4(stateDir, "audit");
+  const path2 = join3(stateDir, "audit");
   return {
     id: "audit:read-errors",
     category: "audit",
@@ -11017,7 +11193,7 @@ var SafetyAuditArtifactProvider = class {
     }
     const selected = [...currentSessionAuditRows(read.rows, this.deps.sessionMeta?.id)].sort(compareAuditRowsNewestFirst).slice(0, SAFETY_AUDIT_ARTIFACT_LIMIT);
     const artifacts = selected.map((row2) => {
-      const path2 = join4(this.deps.stateDir, "audit", row2.file);
+      const path2 = join3(this.deps.stateDir, "audit", row2.file);
       const runId = readStringField2(row2.row, "runId");
       const sessionId = readStringField2(row2.row, "sessionId");
       const correlationId = readStringField2(row2.row, "correlationId") ?? row2.correlationId;
@@ -11101,7 +11277,7 @@ async function listViewArtifacts(providers) {
 }
 
 // src/interactive/worker-receipts.ts
-function isRecord8(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString(value) {
@@ -11117,12 +11293,12 @@ function elapsedMsFrom(receipt) {
   return Math.max(0, endedAt - startedAt);
 }
 function contractFrom(receipt) {
-  const quality = isRecord8(receipt.quality) ? receipt.quality : null;
+  const quality = isRecord7(receipt.quality) ? receipt.quality : null;
   if (quality === null) return void 0;
   if (!Object.hasOwn(quality, "resultContract")) return void 0;
   const fact = quality.resultContract;
   if (fact === null) return "unmeasured";
-  if (!isRecord8(fact)) return void 0;
+  if (!isRecord7(fact)) return void 0;
   const conformance = fact.conformance;
   return conformance === "pass" || conformance === "fail" || conformance === "not-reached" ? conformance : void 0;
 }
@@ -11134,8 +11310,8 @@ var PRESENTED_RESULT_CONTRACTS = [
   "scout-report"
 ];
 function contractKindFrom(receipt) {
-  const quality = isRecord8(receipt.quality) ? receipt.quality : null;
-  const fact = quality !== null && isRecord8(quality.resultContract) ? quality.resultContract : null;
+  const quality = isRecord7(receipt.quality) ? receipt.quality : null;
+  const fact = quality !== null && isRecord7(quality.resultContract) ? quality.resultContract : null;
   const sourceId = optionalString(fact?.sourceId);
   if (sourceId === void 0) return void 0;
   return PRESENTED_RESULT_CONTRACTS.find((kind) => sourceId.startsWith(`agent-result-contract:${kind}:`));
@@ -11143,7 +11319,7 @@ function contractKindFrom(receipt) {
 function workerReceiptFacts(receipt) {
   const outcome = optionalString(receipt.outcome);
   if (outcome === void 0) return null;
-  const output = isRecord8(receipt.output) ? receipt.output : null;
+  const output = isRecord7(receipt.output) ? receipt.output : null;
   const contract = contractFrom(receipt);
   const contractKind = contractKindFrom(receipt);
   const text = optionalString(output?.text);
@@ -11169,11 +11345,11 @@ function workerReceiptFacts(receipt) {
 function readReceiptFileFacts(runId, stateDir) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(receiptFilePath(stateDir, runId), "utf8"));
+    parsed = JSON.parse(readFileSync5(receiptFilePath(stateDir, runId), "utf8"));
   } catch {
     return null;
   }
-  if (!isRecord8(parsed)) return null;
+  if (!isRecord7(parsed)) return null;
   const facts = workerReceiptFacts(parsed);
   if (facts === null) return null;
   const row2 = findRunRow(runId, stateDir);
@@ -11185,13 +11361,13 @@ function readWorkerReceiptFacts(runId, stateDir = clioStateDir()) {
   return readReceiptFileFacts(runId, stateDir);
 }
 function findRunRow(runId, stateDir) {
-  const path2 = join5(stateDir, "runs.json");
-  if (!existsSync4(path2)) return null;
+  const path2 = join4(stateDir, "runs.json");
+  if (!existsSync3(path2)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path2, "utf8"));
     if (!Array.isArray(parsed)) return null;
     for (const entry of parsed) {
-      if (isRecord8(entry) && entry.id === runId) return entry;
+      if (isRecord7(entry) && entry.id === runId) return entry;
     }
     return null;
   } catch {
@@ -11534,6 +11710,7 @@ function richMessageFromEntry(entry, maxTextChars) {
       "responseModelIdObservation",
       "responseModel",
       "responseId",
+      "providerThinkingLevel",
       "gatewayRouting",
       "diagnostics",
       "contextUsageInvalidated"
@@ -11727,7 +11904,7 @@ function replayResultSummary(result) {
   const summary = result.resultSummary ?? toolResultSummary(result.result);
   const offloadPath = typeof summary.offloadPath === "string" && summary.offloadPath.length > 0 ? summary.offloadPath : null;
   if (offloadPath === null) return result.resultSummary;
-  return { ...summary, offloadFileMissing: !existsSync5(offloadPath) };
+  return { ...summary, offloadFileMissing: !existsSync4(offloadPath) };
 }
 function extractToolResult(entry) {
   const payload = entry.payload;
@@ -11948,6 +12125,11 @@ function appendContextMessage(out, role, text, timestamp) {
   if (trimmed.length === 0) return;
   out.push(makeTextMessage(role, truncateReplayText(trimmed), timestamp));
 }
+var UNVERIFIED_SKILL_CHECKPOINT_TEXT = "Preserved skill instructions on this checkpoint failed integrity verification and were not replayed. If a skill still applies, ask the operator to run /skill <name> again.";
+function unverifiedSkillContextText(skill) {
+  const activation = skill.activation;
+  return `Preserved skill instructions for ${activation.name} (source=${activation.source} hash=${activation.hash} path=${activation.filePath}) could not be re-verified against this session's ledger and were not replayed. If the skill still applies, recall the original load with context(scope="recall", ref="${skill.resultRef}") or ask the operator to run /skill ${activation.name} again.`;
+}
 function skillActivationContextText(entry) {
   const activation = entry.activation;
   const turn = activation.turnId ? ` turn=${activation.turnId}` : "";
@@ -11956,6 +12138,16 @@ function skillActivationContextText(entry) {
 function buildReplayAgentMessagesFromTurns(turns, options = {}) {
   const out = createOrderedReplaySink();
   const seenToolCalls = /* @__PURE__ */ new Set();
+  const activeEntries = truncateAtTurn(
+    filterEntriesToActivePath(turns, options.activeLeafTurnId ?? options.uptoTurnId),
+    options.uptoTurnId
+  );
+  const skillState = latestSkillContextState(activeEntries);
+  const evidence = truncateAtTurn(
+    filterEntriesToActivePath(options.skillContextEntries ?? turns, options.activeLeafTurnId ?? options.uptoTurnId),
+    options.uptoTurnId
+  );
+  const verified = captureSkillContext(evidence, skillState);
   for (const entry of selectReplayEntries(turns, options)) {
     switch (entry.kind) {
       case "message": {
@@ -11989,8 +12181,36 @@ function buildReplayAgentMessagesFromTurns(turns, options = {}) {
         break;
       case "compactionSummary":
         appendContextMessage(out, "user", compactionContextText(entry), entry.timestamp);
+        if (entry.userContext)
+          out.push(
+            makeTextMessage("user", `Active user instructions (verbatim):
+${entry.userContext.text}`, entry.timestamp)
+          );
+        if (entry.skillContext !== void 0) {
+          const retainedSkills = entry.skillContext.skills.length;
+          if (!verifiedSkillContextCheckpoint(entry.skillContext)) {
+            if (retainedSkills > 0) {
+              out.push(makeTextMessage("user", UNVERIFIED_SKILL_CHECKPOINT_TEXT, entry.timestamp));
+            }
+            break;
+          }
+          for (const skill of entry.skillContext.skills) {
+            if (skillState && !skillState.unknown && !skillState.activationRefs.includes(skill.activationRef)) continue;
+            const receipt = verified?.skills.find((candidate) => candidate.activationRef === skill.activationRef);
+            if (!receipt || JSON.stringify(receipt) !== JSON.stringify(skill)) {
+              out.push(makeTextMessage("user", unverifiedSkillContextText(skill), entry.timestamp));
+              continue;
+            }
+            out.push(makeTextMessage("user", `Preserved skill request (verbatim):
+${skill.requestText}`, entry.timestamp));
+            out.push(makeTextMessage("user", `Verified loaded skill: ${JSON.stringify(skill.activation)}`, entry.timestamp));
+            for (const block of skill.content) out.push(makeTextMessage("user", block.text, entry.timestamp));
+          }
+        }
         break;
       case "skillActivation":
+        if (entry.activation.runId !== void 0 || skillState && !skillState.activationRefs.includes(entry.turnId))
+          break;
         appendContextMessage(out, "user", skillActivationContextText(entry), entry.timestamp);
         break;
       // The one custom entry that becomes a model message. `/handoff` seeds a
@@ -12209,8 +12429,8 @@ function rehydrateChatPanelFromTurns(chatPanel, turns, options = {}) {
 // src/interactive/model-session-replay.ts
 function buildModelReplayAgentMessagesFromTurns(entries, options = {}) {
   const activeLeafTurnId = options.activeLeafTurnId ?? options.uptoTurnId;
-  const projected = projectWorkingSet(entries, foldWorkingSet(entries, activeLeafTurnId));
-  return buildReplayAgentMessagesFromTurns(projected, options);
+  const projected = projectWorkingSet(entries, foldWorkingSet(entries, activeLeafTurnId), activeLeafTurnId);
+  return buildReplayAgentMessagesFromTurns(projected, { ...options, skillContextEntries: entries });
 }
 
 // src/interactive/turn-context.ts
@@ -12226,6 +12446,7 @@ function evictionSkipMessage(visibleEntries, workingSet, policyId) {
 function createTurnContext(deps) {
   const { state, middleware } = deps;
   const compactionTrigger = new AutoCompactionTrigger();
+  let compactionController = null;
   let currentContextSnapshot = null;
   let reconciledAnchor = null;
   let lastCompactionEvent = null;
@@ -12239,7 +12460,7 @@ function createTurnContext(deps) {
   let resumedPromptHash = null;
   const sessionWorkingContextPaths = /* @__PURE__ */ new Set();
   let pendingPromptLogEntry = null;
-  let emptyAutoCompactTurnId = null;
+  let emptyAutoCompactContextKey = null;
   const pendingColdReasons = /* @__PURE__ */ new Set();
   let runExpectedColdReasons = [];
   let nextAssistantColdReasons = [];
@@ -12402,18 +12623,25 @@ function createTurnContext(deps) {
     }
     return { contextWindow: 0, contextWindowSource: null, contextWindowSlots: null };
   };
-  const reconciledAnchoredTokens = (agentRuntime, pendingUserTokens) => {
+  const anchorModelKey = (agentRuntime) => {
+    const model = agentRuntime.agent.state.model;
+    return JSON.stringify([model?.id, model?.provider, model?.api, model?.baseUrl]);
+  };
+  const reconciledHistoryTokens = (agentRuntime) => {
     const anchor = reconciledAnchor;
     if (!anchor) return null;
     const messages = agentRuntime.agent.state.messages;
-    if (anchor.anchoredMessageCount > messages.length) return null;
+    if (anchor.runtime !== agentRuntime || anchor.model !== agentRuntime.agent.state.model || anchor.modelKey !== anchorModelKey(agentRuntime) || anchor.targetId !== agentRuntime.targetId || anchor.runtimeId !== agentRuntime.runtimeId || anchor.wireModelId !== agentRuntime.wireModelId || anchor.anchoredMessages.length > messages.length || anchor.anchoredMessages.some((message, index) => message !== messages[index])) {
+      reconciledAnchor = null;
+      return null;
+    }
     let tail = 0;
-    for (let i = anchor.anchoredMessageCount; i < messages.length; i += 1) {
+    for (let i = anchor.anchoredMessages.length; i < messages.length; i += 1) {
       const message = messages[i];
       if (message === void 0) continue;
       tail += estimateAgentMessageTokens(message);
     }
-    return anchor.tokens + tail + pendingUserTokens;
+    return anchor.tokens + tail;
   };
   const liveContextEstimate = (agentRuntime, pendingUserText) => {
     const contextWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
@@ -12424,8 +12652,10 @@ function createTurnContext(deps) {
       ...pendingUserText !== void 0 ? { pendingUserText } : {}
     };
     const breakdown = estimateAgentContextBreakdown(estimateInput);
-    const estimatedTokens = estimateAgentContextTokens(estimateInput);
-    const reconciledTokens = reconciledAnchoredTokens(agentRuntime, breakdown.pendingUserTokens);
+    const historyTokens = reconciledHistoryTokens(agentRuntime);
+    const anchor = reconciledAnchor;
+    const reconciledTokens = historyTokens !== null && anchor ? historyTokens + breakdown.pendingUserTokens + Math.max(0, breakdown.systemPromptTokens - anchor.systemPromptTokens) + Math.max(0, breakdown.toolSchemaTokens - anchor.toolSchemaTokens) : null;
+    const estimatedTokens = reconciledTokens === null ? estimateAgentContextTokens(estimateInput) : breakdown.systemPromptTokens + breakdown.messageTokens + breakdown.pendingUserTokens + breakdown.toolSchemaTokens;
     return {
       // 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
@@ -12437,11 +12667,12 @@ function createTurnContext(deps) {
       breakdown
     };
   };
-  const carryReconciledAnchorThroughProjection = (agentRuntime, tokensRemoved) => {
-    if (!reconciledAnchor) return;
+  const carryReconciledAnchorThroughProjection = (agentRuntime, historyTokens, tokensRemoved) => {
+    if (!reconciledAnchor || historyTokens === null) return;
     reconciledAnchor = {
-      tokens: Math.max(0, reconciledAnchor.tokens - Math.max(0, tokensRemoved)),
-      anchoredMessageCount: agentRuntime.agent.state.messages.length
+      ...reconciledAnchor,
+      tokens: Math.max(0, historyTokens - Math.max(0, tokensRemoved)),
+      anchoredMessages: [...agentRuntime.agent.state.messages]
     };
   };
   const refreshAgentMessagesFromSession = (agentRuntime) => {
@@ -12483,27 +12714,54 @@ function createTurnContext(deps) {
       usage.targetId === void 0 && usage.modelId === void 0 ? agentRuntime.runtimeResolution.costProvenance : usage.cost.total > 0 ? "estimated" : "unknown"
     );
   };
-  const runAutoCompact = async (agentRuntime, force, instructions, triggerOverride, pendingUserText) => {
+  const runAutoCompact = async (agentRuntime, force, instructions, triggerOverride, pendingUserText, pendingSkillPolicy, signal) => {
     if (!deps.readSessionEntries) return false;
-    const activeAutoTurnId = force ? null : state.activeUserTurnId;
-    if (activeAutoTurnId && emptyAutoCompactTurnId === activeAutoTurnId) return false;
+    const useRequestBudget = !force || triggerOverride === "overflow";
+    const activeAutoTurnId = useRequestBudget ? state.activeUserTurnId : null;
+    const skillContextState = mainSkillContextState(
+      filterEntriesToActivePath(deps.readSessionEntries(), state.lastTurnId ?? void 0),
+      pendingSkillPolicy ?? state.currentPendingSkillPolicy ?? state.activeSkillSurface
+    );
     const settings = deps.getSettings();
     const cfg = settings.context.compaction;
     const autoEnabled = cfg?.auto !== false;
     if (!force && !autoEnabled) return false;
+    const compactionThreshold = cfg?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
+    const pressureEstimate = force ? null : liveContextEstimate(agentRuntime, pendingUserText);
+    if (pressureEstimate && !shouldCompact(pressureEstimate.tokens, compactionThreshold, pressureEstimate.contextWindow).shouldCompact)
+      return false;
+    const attemptKey = !force && activeAutoTurnId ? createHash3("sha256").update(
+      JSON.stringify({
+        turn: activeAutoTurnId,
+        leaf: state.lastTurnId,
+        entries: deps.readSessionEntries(),
+        context: {
+          systemPrompt: agentRuntime.agent.state.systemPrompt,
+          messages: agentRuntime.agent.state.messages,
+          tools: agentRuntime.agent.state.tools,
+          model: agentRuntime.agent.state.model,
+          thinkingLevel: agentRuntime.agent.state.thinkingLevel
+        },
+        pendingUserText,
+        skillContextState,
+        estimate: pressureEstimate,
+        compaction: cfg,
+        workingSet: settings.context.workingSet,
+        output: settings.chat.maxOutputTokens
+      })
+    ).digest("hex") : null;
+    if (attemptKey && emptyAutoCompactContextKey === attemptKey) return false;
     let preSummaryStageActed = false;
     let evictionSkipNotice = null;
     const rememberEmptyAutomaticAttempt = () => {
-      if (!force && !preSummaryStageActed && activeAutoTurnId) emptyAutoCompactTurnId = activeAutoTurnId;
+      if (!force && !preSummaryStageActed && attemptKey) emptyAutoCompactContextKey = attemptKey;
     };
-    const compactionThreshold = cfg?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
     const trigger = triggerOverride ?? (force ? "force" : "auto");
-    if (!force) {
-      const estimate = liveContextEstimate(agentRuntime, pendingUserText);
+    if (pressureEstimate) {
+      const estimate = pressureEstimate;
       const verdict = shouldCompact(estimate.tokens, compactionThreshold, estimate.contextWindow);
-      if (!verdict.shouldCompact) return false;
       if (deps.session?.current()) {
-        const beforeSnapshotId2 = currentContextSnapshot?.snapshotId ?? null;
+        const beforeSnapshotId = currentContextSnapshot?.snapshotId ?? null;
         if (process.env.CLIO_CODER_LEGACY_MASK === "1") {
           let masked;
           try {
@@ -12548,7 +12806,7 @@ function createTurnContext(deps) {
               maskedThinkingBlocks: masked.maskedThinkingBlocks,
               maskedThinkingChars: masked.maskedThinkingChars,
               trigger,
-              snapshotIdBefore: beforeSnapshotId2,
+              snapshotIdBefore: beforeSnapshotId,
               snapshotIdAfter: postMaskSnapshot.snapshotId,
               at: Date.now()
             });
@@ -12594,11 +12852,12 @@ function createTurnContext(deps) {
             middleware.fireCompactionHook("working_set_evict", "pressure", estimate.tokens);
             emitCompactionActivity("started", "compacting context (working-set eviction)");
             try {
+              const historyTokens = reconciledHistoryTokens(agentRuntime);
               deps.session.appendEntry({
                 ...buildEvictionFields(planned, {
                   trigger: "pressure",
                   pressureBefore: verdict.pressure,
-                  snapshotIdBefore: beforeSnapshotId2
+                  snapshotIdBefore: beforeSnapshotId
                 }),
                 // appendEntry does not infer this anchor; the interactive
                 // cursor is the leaf the next message will extend.
@@ -12606,7 +12865,7 @@ function createTurnContext(deps) {
               });
               noteColdReason("working_set_evict");
               refreshAgentMessagesFromSession(agentRuntime);
-              carryReconciledAnchorThroughProjection(agentRuntime, planned.tokensBefore - planned.tokensAfter);
+              carryReconciledAnchorThroughProjection(agentRuntime, historyTokens, planned.tokensBefore - planned.tokensAfter);
               const postEvictionSnapshot = captureRuntimeContextSnapshot(
                 agentRuntime,
                 state.activeUserTurnId || "compaction",
@@ -12626,7 +12885,7 @@ function createTurnContext(deps) {
                 tokensBefore: planned.tokensBefore,
                 tokensAfter: planned.tokensAfter,
                 trigger,
-                snapshotIdBefore: beforeSnapshotId2,
+                snapshotIdBefore: beforeSnapshotId,
                 snapshotIdAfter: postEvictionSnapshot.snapshotId,
                 policyId: planned.policyId,
                 evictedItems: planned.items.length,
@@ -12670,13 +12929,57 @@ function createTurnContext(deps) {
     if (force) startSummaryLifecycle();
     if (evictionSkipNotice) deps.emitNotice(evictionSkipNotice);
     let result = null;
-    const beforeSnapshotId = currentContextSnapshot?.snapshotId ?? null;
+    const snapshotMetadata = currentContextSnapshot && currentContextSnapshot.systemPrompt === agentRuntime.agent.state.systemPrompt ? { promptSegments: currentContextSnapshot.promptSegments, promptHash: currentContextSnapshot.promptHash } : {};
+    const preCompactSnapshot = captureRuntimeContextSnapshot(
+      agentRuntime,
+      state.activeUserTurnId || "compaction",
+      compactionThreshold,
+      snapshotMetadata
+    );
+    let budget = skillContextState !== void 0 ? { skillContextState } : void 0;
+    if (useRequestBudget) {
+      const estimate = liveContextEstimate(agentRuntime, pendingUserText);
+      const output = Math.min(
+        resolveReservedOutputTokens(agentRuntime.agent.state.model?.maxTokens, {
+          api: agentRuntime.agent.state.model?.api ?? "",
+          contextWindow: estimate.contextWindow,
+          inputTokens: estimate.tokens
+        }),
+        settings.chat.maxOutputTokens > 0 ? settings.chat.maxOutputTokens : Number.POSITIVE_INFINITY
+      );
+      const inputTarget = Math.min(estimate.contextWindow * compactionThreshold, estimate.contextWindow - output);
+      const staticTokens = estimate.breakdown.systemPromptTokens + estimate.breakdown.toolSchemaTokens;
+      const calibration = Math.max(
+        0,
+        estimate.tokens - staticTokens - estimate.breakdown.messageTokens - estimate.breakdown.pendingUserTokens
+      );
+      const historyBudget = inputTarget - staticTokens - estimate.breakdown.pendingUserTokens - calibration;
+      budget = {
+        ...budget,
+        keepRecentTokens: Math.min(DEFAULT_KEEP_RECENT_TOKENS, Math.max(1, Math.floor(historyBudget / 2))),
+        ...activeAutoTurnId ? { preserveUserTurnId: activeAutoTurnId } : {}
+      };
+    }
+    let summarySignal = compactionController?.signal;
     try {
-      result = await compactionTrigger.fire(() => (deps.autoCompact ?? (async () => null))(instructions, trigger));
+      result = await compactionTrigger.fire(async () => {
+        const controller = new AbortController();
+        compactionController = controller;
+        summarySignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        try {
+          return await deps.autoCompact?.(instructions, trigger, {
+            ...budget,
+            signal: summarySignal
+          }) ?? null;
+        } finally {
+          if (compactionController === controller) compactionController = null;
+        }
+      });
     } catch (error) {
       if (!summaryLifecycleStarted) startSummaryLifecycle();
       emitCompactionActivity("failed", compactionFailureMessage(error));
       deps.bus?.emit(BusChannels.CompactionEnd, { trigger, at: Date.now() });
+      summarySignal?.throwIfAborted();
       throw error;
     }
     if (!result || result.summary.length === 0) {
@@ -12696,32 +12999,35 @@ function createTurnContext(deps) {
     const postCompactSnapshot = captureRuntimeContextSnapshot(
       agentRuntime,
       state.activeUserTurnId || "compaction",
-      compactionThreshold
+      compactionThreshold,
+      snapshotMetadata
     );
     currentContextSnapshot = postCompactSnapshot;
+    persistContextSnapshot(preCompactSnapshot);
     persistContextSnapshot(postCompactSnapshot);
+    const tokensBefore = snapshotInputTokens(preCompactSnapshot);
     const tokensAfter = snapshotInputTokens(postCompactSnapshot);
     lastCompactionEvent = {
       stage: "llm_summary",
-      tokensBefore: result.tokensBefore,
+      tokensBefore,
       tokensAfter,
       trigger
     };
     deps.bus?.emit(BusChannels.ContextPruned, {
       stage: "llm_summary",
-      tokensBefore: result.tokensBefore,
+      tokensBefore,
       tokensAfter,
       trigger,
-      snapshotIdBefore: beforeSnapshotId,
+      snapshotIdBefore: preCompactSnapshot.snapshotId,
       snapshotIdAfter: postCompactSnapshot.snapshotId,
       at: Date.now()
     });
-    emitCompactionActivity("completed", `compacted ~${result.tokensBefore} -> ~${tokensAfter} tokens`);
+    emitCompactionActivity("completed", `compacted ~${tokensBefore} -> ~${tokensAfter} tokens`);
     deps.emitNotice(
       renderCompactionSummaryLine({
         messagesSummarized: result.messagesSummarized,
         summaryChars: result.summary.length,
-        tokensBefore: result.tokensBefore,
+        tokensBefore,
         isSplitTurn: result.isSplitTurn
       })
     );
@@ -12748,6 +13054,7 @@ function createTurnContext(deps) {
     rememberedLoadedContextWindow,
     refreshAgentMessagesFromSession,
     runAutoCompact,
+    cancelCompaction: () => compactionController?.abort(),
     setCurrentSnapshot(snapshot) {
       currentContextSnapshot = snapshot;
     },
@@ -12757,11 +13064,20 @@ function createTurnContext(deps) {
     },
     reconcileUsage(usage) {
       const promptTokens = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
-      const messages = state.runtime?.agent.state.messages;
-      if (promptTokens > 0 && messages) {
+      const runtime = state.runtime;
+      if (promptTokens > 0 && runtime) {
+        const breakdown = estimateAgentContextBreakdown({ ...runtime.agent.state, messages: [] });
         reconciledAnchor = {
           tokens: promptTokens + (usage.output || 0),
-          anchoredMessageCount: messages.length
+          anchoredMessages: [...runtime.agent.state.messages],
+          runtime,
+          model: runtime.agent.state.model,
+          modelKey: anchorModelKey(runtime),
+          targetId: runtime.targetId,
+          runtimeId: runtime.runtimeId,
+          wireModelId: runtime.wireModelId,
+          systemPromptTokens: breakdown.systemPromptTokens,
+          toolSchemaTokens: breakdown.toolSchemaTokens
         };
       }
       if (!currentContextSnapshot) return;
@@ -12921,7 +13237,7 @@ function createTurnContext(deps) {
       let compacted = false;
       if (verdict.shouldCompact) {
         try {
-          compacted = await runAutoCompact(agentRuntime, false, void 0, "auto");
+          compacted = await runAutoCompact(agentRuntime, false, void 0, "auto", void 0, void 0, signal);
         } catch (err) {
           throw new Error(
             `[Clio Coder] post-tool context guard could not compact before continuation: ${err instanceof Error ? err.message : String(err)}`
@@ -13069,6 +13385,7 @@ function createTurnContext(deps) {
       }
     },
     resetForSession() {
+      compactionController?.abort();
       if (sessionPromptHash !== null) noteColdReason("prompt_recompiled");
       lastPromptCache = null;
       lastPrewarm = null;
@@ -13079,12 +13396,13 @@ function createTurnContext(deps) {
       resumedPromptHash = null;
       sessionWorkingContextPaths.clear();
       pendingPromptLogEntry = null;
-      emptyAutoCompactTurnId = null;
+      emptyAutoCompactContextKey = null;
       reconciledAnchor = null;
       const session = deps.session?.current();
       currentContextSnapshot = session ? getLatestContextSnapshot(session) : null;
     },
     dispose() {
+      compactionController?.abort();
       for (const unsubscribe of unsubscribeColdReasonSources) unsubscribe?.();
     }
   };
@@ -13253,7 +13571,7 @@ function createTurnMiddleware(deps) {
     },
     flushPendingReminders() {
       if (pendingReminders.length === 0) return "";
-      const messages = pendingReminders.map((entry) => entry.message);
+      const messages = [...new Set(pendingReminders.map((entry) => entry.message))];
       pendingReminders.length = 0;
       return `<system-reminder>
 ${messages.join("\n\n")}
@@ -13371,7 +13689,9 @@ function createTurnPersistence(deps) {
   };
   const appendAssistantTurn = (message, timing) => {
     if (message?.role !== "assistant") return;
+    if (persistedAssistantMessages.has(message)) return;
     if (state.activeInterruptReason !== null && isEmptyAbortedAssistantMessage(message)) return;
+    if (explainInterruptedAssistant(message, state.activeInterruptReason)) state.interruptedAssistantMessage = message;
     const failure2 = terminalFailureFromAssistantMessage(message);
     const payload = assistantSessionPayload(message, failure2);
     if (timing) payload.timing = timing;
@@ -13816,9 +14136,9 @@ function createTurnPrewarm(deps) {
       releaseActiveRound();
     },
     settled() {
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         setTimeout(() => {
-          resolve9(inFlight.catch(() => null));
+          resolve10(inFlight.catch(() => null));
         }, 0);
       });
     },
@@ -13979,7 +14299,7 @@ function createTurnRecovery(deps) {
     deps.emitFailureMessage(message);
   };
   const waitForRetryCountdown = async (status) => {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       let settled = false;
       let currentHandle = null;
       const handle = createRetryCountdown({
@@ -13996,12 +14316,12 @@ function createTurnRecovery(deps) {
         onDone: () => {
           settled = true;
           if (retryCountdown2 === currentHandle) retryCountdown2 = null;
-          resolve9("done");
+          resolve10("done");
         },
         onCancel: () => {
           settled = true;
           if (retryCountdown2 === currentHandle) retryCountdown2 = null;
-          resolve9("cancelled");
+          resolve10("cancelled");
         }
       });
       currentHandle = handle;
@@ -14240,7 +14560,10 @@ function createTurnRuntime(deps) {
       toolOutcomes.set(event.toolCallId, {
         outcome: event.outcome,
         ...event.reason === void 0 ? {} : { reason: event.reason },
-        durationMs: event.durationMs
+        durationMs: event.durationMs,
+        ...event.ruleId === void 0 ? {} : { ruleId: event.ruleId },
+        ...event.reasonCode === void 0 ? {} : { reasonCode: event.reasonCode },
+        ...event.policySource === void 0 ? {} : { policySource: event.policySource }
       });
     }
   };
@@ -14560,6 +14883,9 @@ function createTurnRuntime(deps) {
           resultSummary: toolResultSummary(event.result),
           ...admission === void 0 ? {} : {
             outcome: admission.outcome,
+            ...admission.ruleId === void 0 ? {} : { ruleId: admission.ruleId },
+            ...admission.reasonCode === void 0 ? {} : { reasonCode: admission.reasonCode },
+            ...admission.policySource === void 0 ? {} : { policySource: admission.policySource },
             ...admission.reason === void 0 ? {} : { blockReason: admission.reason }
           }
         };
@@ -14771,6 +15097,7 @@ function createTurnState(initialThinkingLevel) {
     replayedContextMessages: [],
     activeUserTurnId: null,
     activeInterruptReason: null,
+    interruptedAssistantMessage: null,
     interruptedUsage: null,
     synthesisToolLock: false,
     toolProseAbortReason: null,
@@ -14850,10 +15177,18 @@ function createChatLoop(deps) {
   const emitNotice = (text, level = "info", key) => {
     emit({ type: "notice", level, surface: "transcript", text, ...key === void 0 ? {} : { key } });
   };
-  const armSkillSurface = (policy, loadedBefore) => {
+  const armSkillSurface = (policy, loadedBefore, explicitOff = false) => {
     const previous = skillSurfaceNames(state.activeSkillSurface).join(", ");
     const next = armedSkillSurface(policy);
     const current = skillSurfaceNames(next).join(", ");
+    if (deps.session?.current() && (explicitOff || previous.length > 0 || (policy?.loadedSkillNames.size ?? 0) > 0 || (policy?.requests.length ?? 0) > 0)) {
+      const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0);
+      const selection = next ? mainSkillContextState(entries, next) : (policy?.loadedSkillNames.size ?? 0) > 0 ? null : { version: 1, activationRefs: [] };
+      const data = selection ?? { version: 1, activationRefs: [], unknown: true };
+      if (JSON.stringify(data) !== JSON.stringify(latestSkillContextState(entries))) {
+        deps.session.appendEntry({ kind: "custom", customType: SKILL_CONTEXT_STATE, parentTurnId: state.lastTurnId, data });
+      }
+    }
     state.activeSkillSurface = next;
     const activated = skillSurfaceLabels(policy).filter((label) => !loadedBefore?.has(label.split(" ")[0] ?? label));
     if (activated.length > 0) {
@@ -14875,10 +15210,13 @@ function createChatLoop(deps) {
     return target.length > 0 && model.length === 0 ? "model-not-configured" : "orchestrator-not-configured";
   };
   const retrySettings = () => normalizeRetrySettings(deps.getSettings().chat.retry);
+  const hostRunContext = new AsyncLocalStorage();
   const currentToolInvokeOptions = () => {
     const options = {
       toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes
     };
+    const hostRun = hostRunContext.getStore();
+    if (hostRun !== void 0) options.hostRun = hostRun;
     const sessionId = deps.session?.current()?.id ?? null;
     if (sessionId) options.sessionId = sessionId;
     const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -14947,7 +15285,10 @@ function createChatLoop(deps) {
     emitNotice
   });
   const emitRuntimeEvent = (event) => {
-    if (event.type === "message_end") rewriteStallAbortMessage(state, event.message);
+    if (event.type === "message_end") {
+      rewriteStallAbortMessage(state, event.message);
+      explainInterruptedAssistant(event.message, state.activeInterruptReason);
+    }
     emit(event);
   };
   const turnRuntime = createTurnRuntime({
@@ -15100,7 +15441,7 @@ function createChatLoop(deps) {
     interruptRefusal: () => state.streaming ? interruptRefusalReason() : null,
     clearSkillSurface: () => {
       const cleared = skillSurfaceNames(state.activeSkillSurface);
-      armSkillSurface(void 0);
+      armSkillSurface(void 0, void 0, true);
       return cleared;
     },
     clearQueuedFollowUps: () => queues.clearQueuedMirror().map((entry) => entry.text),
@@ -15196,9 +15537,10 @@ function createChatLoop(deps) {
       const forceNow = process.env.CLIO_CODER_FORCE_COMPACT === "1";
       try {
         setTurnPreparation("compacting");
-        await context.runAutoCompact(agentRuntime, forceNow, void 0, void 0, submittedText);
+        await context.runAutoCompact(agentRuntime, forceNow, void 0, void 0, submittedText, pendingSkillPolicy);
       } catch (err) {
         emitNotice(`[Clio Coder] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (err instanceof Error && err.name === "AbortError") return;
       } finally {
         endPreparationCompaction();
       }
@@ -15211,33 +15553,46 @@ function createChatLoop(deps) {
         promptHash: compiledPrompt?.systemPromptHash,
         toolSignature
       });
-      const reservedOutput = resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens);
       const effectiveWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
+      const outputForInput = (inputTokens) => resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens, {
+        api: agentRuntime.agent.state.model?.api ?? "",
+        contextWindow: effectiveWindow,
+        inputTokens
+      });
       const pendingInputTokens = ceilChars(submittedText.length);
       let turnSnapshot = captureTurnSnapshot("pending");
       const budgetedPromptTokens = (snapshot) => Math.max(
         snapshotInputTokens(snapshot) + pendingInputTokens,
         context.liveContextEstimate(agentRuntime, submittedText).tokens
       );
-      const totalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+      const inputEstimate = budgetedPromptTokens(turnSnapshot);
+      const reservedOutput = outputForInput(inputEstimate);
+      const totalEstimate = inputEstimate + reservedOutput;
       if (effectiveWindow > 0 && totalEstimate > effectiveWindow) {
         emitNotice(
           `[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...`
         );
         setTurnPreparation("compacting");
-        const compacted = await context.runAutoCompact(agentRuntime, true, void 0, void 0, submittedText).finally(endPreparationCompaction);
+        let compactionFailure;
+        const compacted = await context.runAutoCompact(agentRuntime, true, void 0, "overflow", submittedText, pendingSkillPolicy).catch((error) => {
+          compactionFailure = error instanceof Error ? error.message : String(error);
+          return false;
+        }).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."
+          emitAdmissionNotice(
+            `[Clio Coder] Request exceeds the context window and compaction could not reclaim enough space.${compactionFailure ? ` ${compactionFailure}.` : ""} Trim the prompt or reduce active tools.`,
+            "context-window-exceeded"
           );
           return;
         }
         context.refreshAgentMessagesFromSession(agentRuntime);
         turnSnapshot = captureTurnSnapshot("pending");
-        const postTotalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+        const postInputEstimate = budgetedPromptTokens(turnSnapshot);
+        const postTotalEstimate = postInputEstimate + outputForInput(postInputEstimate);
         if (postTotalEstimate > effectiveWindow) {
-          emitNotice(
-            `[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`
+          emitAdmissionNotice(
+            `[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`,
+            "context-window-exceeded"
           );
           return;
         }
@@ -15285,6 +15640,7 @@ function createChatLoop(deps) {
       state.toolProseAbortReason = null;
       state.toolProseAssessedChars = 0;
       state.activeInterruptReason = null;
+      state.interruptedAssistantMessage = null;
       state.interruptedUsage = null;
       context.consumeExpectedColdReasons(agentRuntime.runtimeId);
       state.streaming = true;
@@ -15359,12 +15715,17 @@ function createChatLoop(deps) {
         }
         state.streaming = false;
         if (state.activeInterruptReason !== null) {
-          const closing = noticeMessage(state.activeInterruptReason);
-          if (state.interruptedUsage !== null) {
-            closing.usage = state.interruptedUsage;
-          }
-          persistence.appendAssistantTurn(closing);
+          const reason = state.activeInterruptReason;
           state.activeInterruptReason = null;
+          if (state.interruptedAssistantMessage === null) {
+            const closing = noticeMessage(reason);
+            if (state.interruptedUsage !== null) {
+              closing.usage = state.interruptedUsage;
+            }
+            persistence.appendAssistantTurn(closing);
+            emitNotice(reason, "warning", "turn.interrupted");
+          }
+          state.interruptedAssistantMessage = null;
           state.interruptedUsage = null;
         }
         state.currentPendingSkillPolicy = priorPendingSkillPolicy;
@@ -15377,12 +15738,13 @@ function createChatLoop(deps) {
     },
     cancel(options) {
       const wasStreaming = state.streaming;
+      context.cancelCompaction();
       recovery.cancelRetryCountdown();
       queues.clearQueuedMirror();
       const requestedReason = options?.reason?.trim();
       if (wasStreaming) {
         state.activeInterruptReason = requestedReason && requestedReason.length > 0 ? requestedReason : "[Clio Coder] active response cancelled.";
-        emitNotice(state.activeInterruptReason, "warning", "turn.interrupted");
+        emitFooterNotice("warning", state.activeInterruptReason, "turn.interrupted");
       }
       state.runtime?.agent.abort();
       if (wasStreaming && deps.bus) {
@@ -15546,11 +15908,16 @@ function createChatLoop(deps) {
         return;
       }
       let compacted = false;
+      enterPreparation();
+      setTurnPreparation("compacting");
       try {
         compacted = await context.runAutoCompact(agentRuntime, true, instructions, "force");
       } catch (err) {
         emitNotice(`[/context compact] ${err instanceof Error ? err.message : String(err)}`);
         return;
+      } finally {
+        leavePreparation();
+        endPreparationCompaction();
       }
       if (!compacted) {
         emitNotice("[/context compact] nothing to compact; session is empty or no cut crossed");
@@ -15570,12 +15937,13 @@ function createChatLoop(deps) {
   };
   let admissionTail = null;
   api.submit = (text, options = {}) => {
+    const hostRun = options.hostRun === void 0 ? void 0 : structuredClone(options.hostRun);
     prewarm.cancel();
     const previous = admissionTail;
     let release = () => {
     };
-    const ticket = new Promise((resolve9) => {
-      release = resolve9;
+    const ticket = new Promise((resolve10) => {
+      release = resolve10;
     });
     admissionTail = ticket;
     const releaseTicket = () => {
@@ -15595,14 +15963,17 @@ function createChatLoop(deps) {
         await onPreparationVisible?.();
       } catch {
       }
-      return submitTracked(text, {
-        ...submitOptions,
-        onAdmitted: () => {
-          releaseTicket();
-          leaveOnce();
-          options.onAdmitted?.();
-        }
-      }).finally(releaseTicket);
+      return hostRunContext.run(
+        hostRun,
+        () => submitTracked(text, {
+          ...submitOptions,
+          onAdmitted: () => {
+            releaseTicket();
+            leaveOnce();
+            options.onAdmitted?.();
+          }
+        })
+      ).finally(releaseTicket);
     };
     const run = previous ? previous.then(start) : start();
     return run.finally(leaveOnce);
@@ -16434,8 +16805,8 @@ var AskUserOverlayView = class {
     this.setSurface(askUserSurface(this.questions, this.history.length));
     this.rebuildControl();
     this.deps.requestRender();
-    return new Promise((resolve9) => {
-      this.resolveCurrent = resolve9;
+    return new Promise((resolve10) => {
+      this.resolveCurrent = resolve10;
     });
   }
   cancel() {
@@ -16672,7 +17043,7 @@ var AskUserOverlayView = class {
     this.deps.onSurface(next);
   }
   finish(result) {
-    const resolve9 = this.resolveCurrent;
+    const resolve10 = this.resolveCurrent;
     this.resolveCurrent = null;
     this.list = null;
     this.input = null;
@@ -16681,7 +17052,7 @@ var AskUserOverlayView = class {
     if (this.phase !== "closed") this.phase = "waiting";
     if (this.history.length > 0) this.setSurface("interview");
     this.deps.requestRender();
-    resolve9?.(result);
+    resolve10?.(result);
   }
   renderWaiting(width, maxRows) {
     const theme6 = clioTheme();
@@ -17243,6 +17614,7 @@ function openAskUserOverlay(tui, deps) {
     focus: () => handle?.focus(),
     unfocus: (options) => options ? handle?.unfocus(options) : handle?.unfocus(),
     isFocused: () => handle?.isFocused() ?? false,
+    getBounds: () => handle?.getBounds(),
     ask: (questions, presentation) => view.begin(questions, presentation),
     cancel: () => view.cancel(),
     close,
@@ -17416,14 +17788,14 @@ function createAuthDialogController(title, onCancel) {
   });
   input.onSubmit = () => {
     if (!resolver) return;
-    const resolve9 = resolver;
+    const resolve10 = resolver;
     resolver = void 0;
     rejecter = void 0;
     const value = input.getValue();
     promptLabel = null;
     input.setValue("");
     rebuild();
-    resolve9(value);
+    resolve10(value);
   };
   input.onEscape = () => {
     cancel();
@@ -17477,8 +17849,8 @@ function createAuthDialogController(title, onCancel) {
     promptLabel = label;
     input.setValue("");
     rebuild();
-    return new Promise((resolve9, reject) => {
-      resolver = resolve9;
+    return new Promise((resolve10, reject) => {
+      resolver = resolve10;
       rejecter = reject;
     });
   }
@@ -17702,10 +18074,10 @@ function createOverlayAuthLifecycle(deps) {
             },
             onPrompt: async (prompt) => (await dialog.controller.prompt(prompt.message)).trim(),
             onSelect: (prompt) => selectOAuthOption(prompt, [`Target: ${targetId}`, `Runtime: ${runtime.id}`]),
-            onManualCodeInput: async () => await new Promise((resolve9, reject) => {
+            onManualCodeInput: async () => await new Promise((resolve10, reject) => {
               manualCodeTimer = setTimeout(() => {
                 manualCodeTimer = null;
-                dialog.controller.prompt("Verification code").then((value) => resolve9(value.trim())).catch(reject);
+                dialog.controller.prompt("Verification code").then((value) => resolve10(value.trim())).catch(reject);
               }, 1e4);
               manualCodeTimer.unref?.();
             }),
@@ -20549,6 +20921,7 @@ function createOverlayGeneralOpeners(deps) {
       fleetRootId,
       dispatch: deps.dispatch,
       agents: { getSpec: (agentId) => agents.getSpec(agentId) },
+      ...deps.getDecisionBoard ? { getDecisionBoard: deps.getDecisionBoard } : {},
       attributionEnabled: deps.getSettings?.().integrations.git.commitAttribution ?? true,
       vars: preview.vars,
       onStepDispatched: (event) => {
@@ -22370,12 +22743,12 @@ function scopedModelsSubmenu(selectedRefs, providers) {
     "Target entries cycle by target, using its default model when switching targets. Model entries pin one exact target/model reference."
   );
 }
-function chainSubmenus(first, second, join12) {
+function chainSubmenus(first, second, join11) {
   return (_currentValue, done) => {
     let active = first("", (head) => {
       const trimmed = head?.trim() ?? "";
       if (!trimmed) return done();
-      active = second(trimmed)("", (tail) => done(tail?.trim() ? join12(trimmed, tail.trim()) : void 0));
+      active = second(trimmed)("", (tail) => done(tail?.trim() ? join11(trimmed, tail.trim()) : void 0));
     });
     return {
       render: (width) => active.render(width),
@@ -23686,11 +24059,11 @@ function applyEntrySettingChange(settings, id, value) {
 }
 function changedLeafPaths(before, after) {
   const out = [];
-  const isRecord10 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+  const isRecord9 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
   const visit = (a, b, path2) => {
     if (a === b) return;
     const profileLeaf = path2.startsWith("fleet.profiles.") && path2.split(".").length === 3;
-    if (!isRecord10(a) || !isRecord10(b) || profileLeaf) {
+    if (!isRecord9(a) || !isRecord9(b) || profileLeaf) {
       if (JSON.stringify(a) !== JSON.stringify(b)) out.push(path2);
       return;
     }
@@ -26451,14 +26824,14 @@ function openSkillsHub(tui, deps) {
   let pendingWithRequirements = null;
   const columns = () => typeof process.stdout.columns === "number" ? process.stdout.columns : 100;
   let handle;
-  const confirmInstall = deps.confirmInstall ?? ((subject) => new Promise((resolve9) => {
+  const confirmInstall = deps.confirmInstall ?? ((subject) => new Promise((resolve10) => {
     handle.setHidden(true);
     const settle = (accepted) => {
       if (!closed) {
         handle.setHidden(false);
         handle.focus();
       }
-      resolve9(accepted);
+      resolve10(accepted);
     };
     const confirmation = openLibraryInstallConfirmOverlay(tui, {
       subject,
@@ -26660,9 +27033,9 @@ init_esm_shims();
 
 // src/domains/session/cwd-fallback.ts
 init_esm_shims();
-import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
 var defaultFsProbe = {
-  exists: (p) => existsSync6(p),
+  exists: (p) => existsSync5(p),
   isDirectory: (p) => {
     try {
       return statSync2(p).isDirectory();
@@ -26700,9 +27073,9 @@ 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 readFileSync6, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join5 } from "node:path";
 function defaultProbe(candidates) {
   for (const candidate of candidates) {
     const result = spawnSync("sh", ["-lc", `command -v ${candidate}`], {
@@ -26734,13 +27107,13 @@ function resolveExternalEditor(env = process.env, probe = defaultProbe) {
 }
 function editTextExternally(initialText, command) {
   if (!command) return { ok: false, error: "no external editor configured; set VISUAL or EDITOR" };
-  const tmpFile = join6(tmpdir(), `clio-coder-editor-${process.pid}-${randomUUID2()}.md`);
+  const tmpFile = join5(tmpdir(), `clio-coder-editor-${process.pid}-${randomUUID2()}.md`);
   try {
     writeFileSync(tmpFile, initialText, "utf8");
     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: readFileSync6(tmpFile, "utf8").replace(/\n$/, "") };
   } finally {
     try {
       unlinkSync(tmpFile);
@@ -27065,7 +27438,7 @@ function openMessagePickerOverlay(tui, deps) {
     anchor: "center",
     width: MESSAGE_PICKER_OVERLAY_WIDTH,
     markerId: "message-picker",
-    title: "Fork",
+    title: "Fork conversation; workspace files stay unchanged",
     footerHint: rows.length > 0 ? buildHint([{ key: "Enter", verb: "select" }]) : buildHint([])
   });
 }
@@ -27938,6 +28311,12 @@ function createOverlaySessionLifecycle(deps) {
           }
           deps.resetTranscript();
           replayFork(forkedSessionId, parentTurnId, session);
+          emitCommandNotice(
+            deps.getSlashNotice(),
+            "info",
+            "fork",
+            "Conversation forked. Workspace files were not rewound; existing edits remain."
+          );
         } catch (error) {
           deps.stderr(`[/fork] fork failed: ${error instanceof Error ? error.message : String(error)}
 `);
@@ -28088,9 +28467,9 @@ function createOverlaySessionLifecycle(deps) {
     openHandoffReview(session, fromSessionId, goal, document);
   }
   function editHandoffDocument(current) {
-    const resolve9 = deps.resolveEditor ?? resolveExternalEditor;
+    const resolve10 = deps.resolveEditor ?? resolveExternalEditor;
     const edit = deps.editExternally ?? editTextExternally;
-    const command = resolve9();
+    const command = resolve10();
     if (!command) {
       deps.notify("warning", "handoff: no external editor configured; set VISUAL or EDITOR", "handoff:no-editor");
       return null;
@@ -28785,8 +29164,8 @@ function resolveApplicationCtrlCAction(state) {
 function createApplicationController(deps) {
   let resolveRun = () => {
   };
-  const run = new Promise((resolve9) => {
-    resolveRun = resolve9;
+  const run = new Promise((resolve10) => {
+    resolveRun = resolve10;
   });
   const keepAlive = deps.intervals.setInterval(() => {
   }, 1 << 30);
@@ -29087,15 +29466,18 @@ function formatSteerCandidates(runs) {
 
 // src/interactive/editor-submit.ts
 var EDITOR_BASH_TIMEOUT_MS = 3e5;
+var EDITOR_BASH_SHUTDOWN_MS = 6e3;
 function isRejectedCommand(command) {
   return command.kind === "usage-error";
 }
 function createEditorSubmitController(deps) {
+  let shuttingDown = false;
   let activeEditorBash = null;
   let activeEditorBashSettlement = null;
   const runEditorBash = (text) => {
     const parsed = parseEditorBashCommand(text);
     if (!parsed) return false;
+    if (shuttingDown) return true;
     if (deps.chat.isStreaming()) {
       deps.io.stderr("[bash] response in progress. Press Esc to cancel the active run before running a local command.\n");
       return true;
@@ -29330,12 +29712,14 @@ function createEditorSubmitController(deps) {
     const literalText = unguardPastedEditorOperator(text);
     const trimmed = literalText.trim();
     if (trimmed.length === 0) return;
+    if (shuttingDown) throw new Error("editor is shutting down");
     signal?.throwIfAborted();
     deps.collapseLaunchpadBeforeSubmit?.();
     if (parseEditorBashCommand(text)) {
       while (deps.chat.isStreaming()) await awaitWithAbort(deps.chat.whenSettled(), signal);
       while (activeEditorBashSettlement) await awaitWithAbort(activeEditorBashSettlement, signal);
       signal?.throwIfAborted();
+      if (shuttingDown) throw new Error("editor is shutting down");
       deps.editor.addToHistory(literalText);
       runEditorBash(text);
       deps.ui.requestRender();
@@ -29455,6 +29839,11 @@ function createEditorSubmitController(deps) {
     interruptFromEditor,
     restoreQueuedFollowUpsToEditor,
     hasActiveEditorBash: () => activeEditorBash !== null,
+    shutdownEditorBash: async () => {
+      shuttingDown = true;
+      activeEditorBash?.abort();
+      await activeEditorBashSettlement;
+    },
     cancelActiveEditorBash: () => {
       if (!activeEditorBash) return false;
       activeEditorBash.abort();
@@ -29920,9 +30309,10 @@ function createInteractiveEventProjection(deps) {
     deps.bus.on(BusChannels.ContextPruned, (payload) => {
       const event = payload;
       if (event && typeof event === "object" && typeof event.tokensBefore === "number" && typeof event.tokensAfter === "number") {
+        const outcome = event.tokensAfter < event.tokensBefore ? "Reclaimed context" : "Context updated";
         deps.notify(
           "info",
-          `[Compaction] Reclaimed context: ${event.tokensBefore} -> ${event.tokensAfter} tokens (${event.stage})`,
+          `[Compaction] ${outcome}: ${event.tokensBefore} -> ${event.tokensAfter} tokens (${event.stage})`,
           "compaction-notice"
         );
       }
@@ -30043,6 +30433,11 @@ function createInteractiveEventProjection(deps) {
   );
   const seenMiddlewareBudgetWarnings = /* @__PURE__ */ new Set();
   remainingUnsubscribers.push(
+    deps.bus.on(BusChannels.ExtensionsLoadIssue, (payload) => {
+      if (typeof payload?.message !== "string" || payload.message.trim().length === 0) return;
+      deps.appendTranscriptNotice("warn", payload.message);
+      deps.requestRender();
+    }),
     deps.bus.on(BusChannels.MiddlewareHookFailed, (payload) => {
       const notice = middlewareHookFailedSessionNotice(payload, seenMiddlewareBudgetWarnings);
       if (notice === null) return;
@@ -30755,7 +31150,7 @@ function headerLine2(entry, width) {
   return fitUnits(theme5, `${originGlyph(entry)} `, identityUnits(entry), width);
 }
 function outcomeUnit(receipt, word) {
-  if (receipt.outcome === "succeeded") return theme5.fg("success", word ? `${GLYPH.ok} ok` : GLYPH.ok);
+  if (receipt.outcome === "succeeded") return theme5.fg("success", `${GLYPH.ok} execution ok`);
   if (receipt.outcome === "canceled") return theme5.fg("dim", `${GLYPH.cancelled} canceled`);
   if (receipt.abandonedDetail !== void 0) return theme5.fg("error", word ? `${GLYPH.error} abandoned` : GLYPH.error);
   return theme5.fg("error", `${GLYPH.error} ${receipt.outcomeCode ?? receipt.outcome}`);
@@ -30976,12 +31371,19 @@ function foldedLine(entry, width, expandKey) {
   const elapsed = entry.receipt?.durationMs === void 0 ? "" : dim3(`${SEPARATOR2}${formatCompactMs(entry.receipt.durationMs)}`);
   const hint = expandKey === void 0 || expandKey.length === 0 ? "" : dim3(` (${expandKey})`);
   const full = ` ${status}${elapsed}${hint}`;
-  const tail = visibleWidth(identity) + visibleWidth(full) <= width ? full : ` ${status}${hint}`;
-  return `${truncateToWidth(identity, Math.max(1, width - visibleWidth(tail)), GLYPH.ellipsis, false)}${tail}`;
+  let tail = visibleWidth(identity) + visibleWidth(full) <= width ? full : ` ${status}${hint}`;
+  if (visibleWidth(tail) >= width) tail = ` ${status}`;
+  const header = `${truncateToWidth(identity, Math.max(1, width - visibleWidth(tail)), GLYPH.ellipsis, false)}${tail}`;
+  return truncateToWidth(header, width, GLYPH.ellipsis, false);
 }
 function renderWorkerEntryLines(entry, width, options) {
   const safeWidth = Math.max(1, Math.floor(width));
-  if (options.folded) return [foldedLine(entry, safeWidth, options.expandKey)];
+  const quality = isPending(entry) ? [] : railLines(
+    `quality: ${trustStateWord("validationGrounding", entry.receipt?.trust?.validationGrounding.state ?? "unknown")}`,
+    "muted",
+    safeWidth
+  );
+  if (options.folded) return [foldedLine(entry, safeWidth, options.expandKey), ...quality];
   const tools = toolLine(entry, safeWidth);
   return [
     headerLine2(entry, safeWidth),
@@ -30989,7 +31391,8 @@ function renderWorkerEntryLines(entry, width, options) {
     ...attemptLines(entry, safeWidth),
     ...tools === null ? [] : [tools],
     ...failureLines(entry, safeWidth),
-    footerLine(entry, safeWidth)
+    footerLine(entry, safeWidth),
+    ...quality
   ];
 }
 
@@ -32470,8 +32873,8 @@ function renderFooterStatusLines(state, width) {
   const safeWidth = Math.max(1, Math.floor(width));
   const header = headerLine3(state.session, safeWidth);
   if (safeWidth >= EXPANDED_ULTRAWIDE) {
-    const sep3 = barSep(theme6);
-    const widths = expandedWideColumnWidths(safeWidth, visibleWidth(sep3) * 3);
+    const sep4 = barSep(theme6);
+    const widths = expandedWideColumnWidths(safeWidth, visibleWidth(sep4) * 3);
     const blocks2 = [
       activityQuadrant(state.agent, {
         width: widths[0],
@@ -32489,14 +32892,14 @@ function renderFooterStatusLines(state, width) {
       sessionQuadrant(state.session, { width: widths[2] }),
       workspaceQuadrant(state.workspace, { width: widths[3] })
     ];
-    return [header, rule(theme6, safeWidth), ...zipColumnBlocks(blocks2, widths, sep3)].map(
+    return [header, rule(theme6, safeWidth), ...zipColumnBlocks(blocks2, widths, sep4)].map(
       (line) => fitDashboardLine(line, safeWidth)
     );
   }
   if (safeWidth >= EXPANDED_WIDE) {
-    const sep3 = barSep(theme6);
-    const [topLeftWidth, topRightWidth] = expandedPairWidths(safeWidth, visibleWidth(sep3));
-    const [bottomLeftWidth, bottomRightWidth] = expandedPairWidths(safeWidth, visibleWidth(sep3));
+    const sep4 = barSep(theme6);
+    const [topLeftWidth, topRightWidth] = expandedPairWidths(safeWidth, visibleWidth(sep4));
+    const [bottomLeftWidth, bottomRightWidth] = expandedPairWidths(safeWidth, visibleWidth(sep4));
     const top = zipColumns2(
       activityQuadrant(state.agent, {
         width: topLeftWidth,
@@ -32513,14 +32916,14 @@ function renderFooterStatusLines(state, width) {
       contextQuadrant(state.context, { width: topRightWidth }),
       topLeftWidth,
       topRightWidth,
-      sep3
+      sep4
     );
     const bottom = zipColumns2(
       sessionQuadrant(state.session, { width: bottomLeftWidth }),
       workspaceQuadrant(state.workspace, { width: bottomRightWidth }),
       bottomLeftWidth,
       bottomRightWidth,
-      sep3
+      sep4
     );
     return [header, rule(theme6, safeWidth), ...top, "", ...bottom].map((line) => fitDashboardLine(line, safeWidth));
   }
@@ -32764,7 +33167,8 @@ function buildFullscreenLayout(parts, options = {}) {
     primary: true,
     overscroll: "chain",
     scrollbar: options.fullscreenScrollbar ?? "auto",
-    scrollbarStyle: () => theme6.fg("frameStrong", GLYPH.barFull)
+    scrollbarTrackStyle: (text) => theme6.fg("frame", text),
+    scrollbarThumbStyle: () => theme6.fg("frameStrong", GLYPH.barFull)
   });
   const dock = new VStack();
   if (parts.pending) dock.addChild(parts.pending, { shrink: 1, minSize: 0 });
@@ -32794,7 +33198,7 @@ init_esm_shims();
 import { execFile as execFile2 } from "node:child_process";
 import { open, readdir, stat as stat2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename3, dirname as dirname2, join as join7, relative as relative7, resolve as resolve5, sep as sep2 } from "node:path";
+import { basename as basename3, dirname, join as join6, relative as relative7, resolve as resolve5, sep as sep2 } from "node:path";
 var MAX_COMPLETION_ROWS = 40;
 var PREVIEW_BYTES = 2048;
 var PREVIEW_CHARS = 120;
@@ -32842,7 +33246,7 @@ function buildWorkspaceSnapshot(basePath, visibleFiles, trackedFiles) {
     const tracked = trackedFiles.has(path2);
     files.push({
       path: path2,
-      absolutePath: join7(basePath, path2),
+      absolutePath: join6(basePath, path2),
       isDirectory: false,
       tracked,
       descendantFiles: 0,
@@ -32860,7 +33264,7 @@ function buildWorkspaceSnapshot(basePath, visibleFiles, trackedFiles) {
   const directories = [...directoryFacts].map(
     ([path2, facts]) => ({
       path: path2,
-      absolutePath: join7(basePath, path2),
+      absolutePath: join6(basePath, path2),
       isDirectory: true,
       tracked: facts.tracked,
       descendantFiles: facts.descendantFiles,
@@ -32874,7 +33278,7 @@ function buildWorkspaceSnapshot(basePath, visibleFiles, trackedFiles) {
   };
 }
 function candidateParent(path2) {
-  const parent = posixPath(dirname2(path2));
+  const parent = posixPath(dirname(path2));
   return parent === "." ? "" : parent;
 }
 function fuzzyOrdered(candidates, query) {
@@ -32935,7 +33339,7 @@ async function explicitCandidates(basePath, query, trackedFiles) {
   const candidates = [];
   for (const entry of await readdir(directory, { withFileTypes: true })) {
     if (entry.name === ".git" || /[\r\n\0]/u.test(entry.name)) continue;
-    const absolutePath = join7(directory, entry.name);
+    const absolutePath = join6(directory, entry.name);
     let isDirectory = entry.isDirectory();
     let isFile = entry.isFile();
     if (!isDirectory && !isFile && entry.isSymbolicLink()) {
@@ -33481,8 +33885,8 @@ function processAutoPacingAllowed(backpressureObserved, env = process.env) {
 
 // src/interactive/welcome-dashboard.ts
 init_esm_shims();
-import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { basename as basename4, join as join8 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { basename as basename4, join as join7 } from "node:path";
 function activeStatus(status) {
   return status.available && status.health.status !== "down";
 }
@@ -33548,14 +33952,14 @@ function wikiFactsFrom(cwd, staleness) {
   };
 }
 function handoffFacts(cwd) {
-  const handoffsDir = join8(cwd, ".clio-coder", "handoffs");
-  if (!existsSync7(handoffsDir)) return { handoffCount: 0, handoffFreshness: "none" };
+  const handoffsDir = join7(cwd, ".clio-coder", "handoffs");
+  if (!existsSync6(handoffsDir)) return { handoffCount: 0, handoffFreshness: "none" };
   try {
     const files = readdirSync2(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md"));
     if (files.length === 0) return { handoffCount: 0, handoffFreshness: "none" };
     let newestMtime = 0;
     for (const file of files) {
-      const mtime = statSync3(join8(handoffsDir, file)).mtimeMs;
+      const mtime = statSync3(join7(handoffsDir, file)).mtimeMs;
       if (mtime > newestMtime) newestMtime = mtime;
     }
     return {
@@ -33593,7 +33997,7 @@ async function readWelcomeRepositoryFactsAsync(cwd) {
 function placeholderRepositoryFacts(cwd) {
   return {
     clioMdStatus: clioMdStatusFor(cwd),
-    hasCodewiki: existsSync7(join8(cwd, ".clio-coder", "codewiki.json")),
+    hasCodewiki: existsSync6(join7(cwd, ".clio-coder", "codewiki.json")),
     codewikiCount: 0,
     wikiPageCount: 0,
     wikiStatus: NO_WIKI_STATUS,
@@ -34077,7 +34481,9 @@ function createInteractivePresentation(deps) {
         label: skill.name,
         description: skill.description
       })),
-      tasks: async () => (deps.getTaskBoard?.()?.tasks ?? []).map((task) => ({
+      tasks: async ({ subcommand }) => (deps.userTasks?.snapshot() ?? []).filter(
+        (task) => subcommand === "hand" ? task.status === "open" : task.status === "open" || task.status === "handed" || task.status === "picked"
+      ).map((task) => ({
         id: task.id,
         value: task.id,
         label: task.title,
@@ -34242,7 +34648,7 @@ function createInteractivePresentation(deps) {
 // src/interactive/interactive-slash-runtime.ts
 init_esm_shims();
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join9, resolve as resolve6 } from "node:path";
+import { join as join8, resolve as resolve6 } from "node:path";
 
 // src/interactive/context-recall-command.ts
 init_esm_shims();
@@ -34254,6 +34660,7 @@ function headlineFor(ref, tokens, state, offloadPath) {
   if (state !== void 0) {
     parts.push(state.by === void 0 ? `evicted: ${state.reason}` : `evicted: ${state.reason} by ${state.by}`);
   }
+  if (state === void 0) parts.push("summarized");
   parts.push(`${formatTokens3(tokens)} tokens`);
   if (offloadPath !== void 0) parts.push(`offload: ${offloadPath}`);
   return `[/context recall] ${parts.join(" \xB7 ")}`;
@@ -34271,7 +34678,7 @@ function runOperatorRecall(ref, deps) {
   const view = foldWorkingSet(entries, leaf);
   const resolved = resolveRecall(entries, view, trimmed, leaf);
   if (!resolved.ok)
-    return { ok: false, message: `[/context recall] ${recallErrorMessage(resolved.error, entries, view)}` };
+    return { ok: false, message: `[/context recall] ${recallErrorMessage(resolved.error, entries, view, leaf)}` };
   const { result } = resolved;
   const fields = buildRecallFields(result, { trigger: "operator" });
   try {
@@ -34589,8 +34996,8 @@ function createInteractiveSlashRuntime(deps) {
       deps.requestRender();
       let acknowledgeAdmission = () => {
       };
-      const admitted = new Promise((resolve9) => {
-        acknowledgeAdmission = resolve9;
+      const admitted = new Promise((resolve10) => {
+        acknowledgeAdmission = resolve10;
       });
       const turn = deps.chat.submit(sub.text, {
         ...sub.images.length > 0 ? { images: sub.images } : {},
@@ -34703,6 +35110,7 @@ function createInteractiveSlashRuntime(deps) {
       });
     },
     dispatch: deps.dispatch,
+    ...deps.getDecisionBoard ? { getDecisionBoard: deps.getDecisionBoard } : {},
     bus: deps.bus,
     ...deps.agents ? { getAgentRoleFacts: agentRoleFactsResolver((agentId) => deps.agents?.getSpec(agentId) ?? null) } : {},
     shutdown: () => {
@@ -34894,7 +35302,7 @@ function createInteractiveSlashRuntime(deps) {
         const requestedPath = pathArg?.trim() ?? "";
         const markdown = requestedPath.toLowerCase().endsWith(".md");
         const target = resolve6(
-          requestedPath.length > 0 ? requestedPath : join9(".clio-coder", "exports", `${sessionId}-${date}.html`)
+          requestedPath.length > 0 ? requestedPath : join8(".clio-coder", "exports", `${sessionId}-${date}.html`)
         );
         mkdirSync2(resolve6(target, ".."), { recursive: true });
         if (markdown) {
@@ -35524,6 +35932,7 @@ async function createInteractiveApplication(deps) {
     ...deps.session ? { session: deps.session } : {},
     ...deps.getSessionId ? { getSessionId: deps.getSessionId } : {},
     ...deps.getTaskBoard ? { getTaskBoard: deps.getTaskBoard } : {},
+    ...deps.userTasks ? { userTasks: deps.userTasks } : {},
     ...deps.getTaskMemoryStatus ? { getTaskMemoryStatus: deps.getTaskMemoryStatus } : {},
     ...deps.getTaskMemorySeedOffer ? { getTaskMemorySeedOffer: deps.getTaskMemorySeedOffer } : {},
     ...deps.getContextState ? { getContextState: deps.getContextState } : {}
@@ -35622,6 +36031,7 @@ async function createInteractiveApplication(deps) {
     io,
     bus: deps.bus,
     dispatch: deps.dispatch,
+    ...deps.getDecisionBoard ? { getDecisionBoard: deps.getDecisionBoard } : {},
     ...deps.session ? { session: deps.session } : {},
     providers: deps.providers,
     chat: deps.chat,
@@ -35721,6 +36131,7 @@ async function createInteractiveApplication(deps) {
     expandSubmit: (text) => expandInteractiveSubmitAsync(text, deps.resources),
     notify
   });
+  getTerminationCoordinator().onDrain(() => editorSubmit.shutdownEditorBash(), { timeoutMs: EDITOR_BASH_SHUTDOWN_MS });
   editor.onSubmit = editorSubmit.submitEditorText;
   const interactiveTickers = createInteractiveTickers({
     tui,
@@ -35975,7 +36386,7 @@ async function createInteractiveApplication(deps) {
     steerSelectedDispatch,
     cancelSelectedDispatch,
     cancelActiveEditorBash: () => editorSubmit.cancelActiveEditorBash(),
-    isStreaming: () => deps.chat.isStreaming(),
+    isStreaming: () => deps.chat.isStreaming() || deps.chat.turnPreparation().phase === "compacting",
     cancelActiveRun,
     editor,
     editorSubmit,
@@ -36168,6 +36579,7 @@ function createExtensionReloadCoordinator(deps) {
     workspaceRoot: workspace,
     ...captured !== null ? { capturedSources: captured } : {},
     recordReceipt: deps.recordReceipt,
+    report: deps.report,
     ...deps.runCommand !== void 0 ? { runCommand: deps.runCommand } : {},
     ...deps.now !== void 0 ? { now: deps.now } : {}
   });
@@ -36442,13 +36854,39 @@ init_esm_shims();
 
 // src/tools/dispatch-admission.ts
 init_esm_shims();
-import { isAbsolute as isAbsolute6, relative as relative8, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute7, relative as relative9, resolve as resolve9 } from "node:path";
+
+// src/domains/dispatch/parallel-writers.ts
+init_esm_shims();
+import { isAbsolute as isAbsolute6, relative as relative8, resolve as resolve8, sep as sep3 } from "node:path";
+function parallelWriterConflict(requests, specs) {
+  const classes = new Map(specs.map((spec) => [spec.id, spec.capabilityClass]));
+  const writers = requests.filter(
+    (request) => request.worktree !== true && request.autonomy !== "read-only" && classes.get(request.agentId) !== "read-only"
+  );
+  const roots = writers.map(
+    (request) => (request.writeRoots ?? request.intent?.writeRoots ?? []).map(
+      (root) => canonicalizeExistingPath(resolve8(request.cwd ?? process.cwd(), root))
+    )
+  );
+  const contains = (parent, child) => {
+    const rel = relative8(parent, child);
+    return rel === "" || !isAbsolute6(rel) && rel !== ".." && !rel.startsWith(`..${sep3}`);
+  };
+  for (let i = 0; i < writers.length; i++)
+    for (let j = i + 1; j < writers.length; j++) {
+      const left = roots[i] ?? [], right = roots[j] ?? [];
+      if (!left.length || !right.length || left.some((a) => right.some((b) => contains(a, b) || contains(b, a)))) {
+        return `parallel_writer_conflict: ${writers[i]?.agentId} and ${writers[j]?.agentId} have overlapping or undeclared write roots. Use worktree: true, declare disjoint intent.write_roots, or serialize writers with writers: 1.`;
+      }
+    }
+  return null;
+}
 
 // src/tools/dispatch-scout-admission.ts
 init_esm_shims();
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
-import { join as join10 } from "node:path";
-var MAX_SCOUT_PLAN_DEADLINE_MS = 36e5;
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { join as join9 } from "node:path";
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -36494,11 +36932,11 @@ function validateScoutSource(receipt, envelope, agentSpecs) {
 function loadVerifiedScoutSource(input) {
   const envelope = input.dispatch.getRun(input.ref.runId);
   if (envelope === null) throw new Error(`dispatch: Scout source run '${input.ref.runId}' is unavailable`);
-  const receiptPath = envelope.receiptPath ?? join10(clioStateDir(), "receipts", `${input.ref.runId}.json`);
-  if (!existsSync8(receiptPath)) throw new Error(`dispatch: Scout source receipt '${input.ref.runId}' is unavailable`);
+  const receiptPath = envelope.receiptPath ?? join9(clioStateDir(), "receipts", `${input.ref.runId}.json`);
+  if (!existsSync7(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(readFileSync7(receiptPath, "utf8"));
   } catch (error) {
     throw new Error(
       `dispatch: Scout source receipt is unreadable: ${error instanceof Error ? error.message : String(error)}`
@@ -36519,8 +36957,8 @@ function prepareScoutContinuation(input) {
     const routingIntent = input.authorization === "full-auto-policy" ? { ...sourceIntent, requiredCapabilities: [...sourceIntent.requiredCapabilities], failover: "approved" } : {
       ...sourceIntent,
       posture: sourceIntent.posture === "manual" ? "balanced" : sourceIntent.posture,
-      maxCostUsd: input.costCeilingUsd,
-      deadlineMs: null,
+      maxCostUsd: sourceIntent.maxCostUsd,
+      deadlineMs: sourceIntent.deadlineMs,
       requiredCapabilities: [...sourceIntent.requiredCapabilities],
       failover: "approved"
     };
@@ -36549,8 +36987,7 @@ function prepareScoutContinuation(input) {
       routingIntent
     });
   }
-  const priorCostCeiling = input.source.receipt.routingIntent.maxCostUsd;
-  const effectiveCostCeiling = input.authorization === "full-auto-policy" && priorCostCeiling !== null ? Math.min(input.costCeilingUsd, priorCostCeiling) : input.costCeilingUsd;
+  const explicitCostCeiling = input.source.receipt.routingIntent.maxCostUsd;
   const bindings = proposals.map(({ subtask, agentSpec }) => ({
     subtaskId: subtask.id,
     spec: agentSpec
@@ -36574,31 +37011,7 @@ function prepareScoutContinuation(input) {
     throw new Error("dispatch: full-auto policy does not grant every requested Scout authority");
   }
   const plan = transition.plan;
-  const p95ByStep = new Map(
-    proposals.map((proposal) => {
-      const selected = proposal.decision.candidateEvaluations.find(
-        (entry) => sameRouteIdentity(entry.candidate, proposal.decision.selected)
-      );
-      if (selected === void 0 || selected.rejection !== null) {
-        throw new Error(`dispatch: Scout step '${proposal.subtask.id}' has no admissible latency estimate`);
-      }
-      return [proposal.subtask.id, selected.estimate.p95EndToEndMs];
-    })
-  );
-  const predictedDeadlineMs = Math.ceil(
-    plan.waves.reduce(
-      (total, wave) => total + Math.max(...wave.map((stepId) => p95ByStep.get(stepId) ?? Number.POSITIVE_INFINITY)),
-      0
-    )
-  );
-  if (!Number.isFinite(predictedDeadlineMs) || predictedDeadlineMs < 1 || predictedDeadlineMs > MAX_SCOUT_PLAN_DEADLINE_MS) {
-    throw new Error("dispatch: Scout continuation exceeds the finite whole-plan deadline ceiling");
-  }
-  const priorDeadlineMs = input.source.receipt.routingIntent.deadlineMs;
-  if (input.authorization === "full-auto-policy" && priorDeadlineMs !== null && predictedDeadlineMs > priorDeadlineMs) {
-    throw new Error("dispatch: full-auto Scout continuation exceeds the previously granted deadline");
-  }
-  const deadlineMs = Math.max(priorDeadlineMs ?? 0, predictedDeadlineMs);
+  const deadlineMs = input.source.receipt.routingIntent.deadlineMs;
   const requests = [];
   const resolutions = [];
   const tasks = requireAgentSteps(plan.steps).map((step, index) => {
@@ -36619,7 +37032,7 @@ function prepareScoutContinuation(input) {
       cwd: input.source.envelope.cwd,
       requestOrigin: "user",
       agentSelection: selection,
-      routingIntent: { ...proposal.routingIntent, maxCostUsd: effectiveCostCeiling, deadlineMs, failover: "none" },
+      routingIntent: { ...proposal.routingIntent, maxCostUsd: explicitCostCeiling, deadlineMs, failover: "none" },
       failover: "none"
     });
     resolutions.push(proposal.resolution);
@@ -36631,7 +37044,7 @@ function prepareScoutContinuation(input) {
       node: proposal.resolution.node.id,
       nodeKind: proposal.resolution.node.kind,
       ...proposal.resolution.node.host === void 0 ? {} : { nodeHost: proposal.resolution.node.host },
-      routingIntent: { ...proposal.routingIntent, maxCostUsd: effectiveCostCeiling, deadlineMs, failover: "none" },
+      routingIntent: { ...proposal.routingIntent, maxCostUsd: explicitCostCeiling, deadlineMs, failover: "none" },
       failover: "none",
       routeApproval: null,
       agentSelection: selection,
@@ -36647,8 +37060,8 @@ function prepareScoutContinuation(input) {
     };
   });
   const aggregateCost = resolutions.reduce((sum, resolution) => sum + resolution.costUpperBoundUsd, 0);
-  if (!Number.isFinite(aggregateCost) || aggregateCost > effectiveCostCeiling) {
-    throw new Error("dispatch: Scout continuation exceeds the scheduling cost ceiling");
+  if (!Number.isFinite(aggregateCost) || explicitCostCeiling !== null && aggregateCost > explicitCostCeiling) {
+    throw new Error("dispatch: Scout continuation exceeds the explicit routing cost ceiling");
   }
   return {
     artifact: {
@@ -36663,7 +37076,7 @@ function prepareScoutContinuation(input) {
       maxWorkers: plan.maxWorkers,
       onFailure: plan.onFailure,
       tasks,
-      costCeilingUsd: effectiveCostCeiling,
+      costCeilingUsd: input.costCeilingUsd,
       deadlineMs
     },
     requests,
@@ -36696,7 +37109,7 @@ function councilSettingsFromArgs(args, deps) {
     if (!Array.isArray(args.members)) return { ok: false, message: "council_members_out_of_range" };
     members = [];
     for (const raw of args.members) {
-      if (!isRecord9(raw)) return { ok: false, message: "council_members_out_of_range" };
+      if (!isRecord8(raw)) return { ok: false, message: "council_members_out_of_range" };
       const label = stringArg(raw, "label");
       const target = stringArg(raw, "target");
       if (label === void 0 || target === void 0 || !COUNCIL_LABEL.test(label)) {
@@ -36726,7 +37139,7 @@ function councilSettingsFromArgs(args, deps) {
   if (!Number.isInteger(rounds) || Number(rounds) < 1 || Number(rounds) > 3) {
     return { ok: false, message: "dispatch: rounds must be an integer 1..3" };
   }
-  const judge = isRecord9(args.judge) ? Object.fromEntries(
+  const judge = isRecord8(args.judge) ? Object.fromEntries(
     ["agent", "model", "target", "node"].flatMap((key) => {
       const value = stringArg(args.judge, key);
       return value === void 0 ? [] : [[key, value]];
@@ -36734,13 +37147,13 @@ function councilSettingsFromArgs(args, deps) {
   ) : void 0;
   return { ok: true, council: { members, synthesis, rounds: Number(rounds), ...judge ? { judge } : {} } };
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function reviewSettingsFromArgs(args) {
   const raw = args.review;
   if (raw === void 0 || raw === false) return { ok: true, review: void 0 };
-  const record2 = raw === true ? {} : isRecord9(raw) ? raw : null;
+  const record2 = raw === true ? {} : isRecord8(raw) ? raw : null;
   if (record2 === null) return { ok: false, message: "dispatch: review must be true or an options object" };
   const review = { maxCycles: REVIEW_MAX_CYCLES_DEFAULT };
   const reviewer = stringArg(record2, "reviewer", "agent");
@@ -36771,10 +37184,10 @@ function competeSettingsFromArgs(args) {
     }
     candidates = args.candidates;
   }
-  if (args.judge !== void 0 && !isRecord9(args.judge)) {
+  if (args.judge !== void 0 && !isRecord8(args.judge)) {
     return { ok: false, message: "dispatch: judge must be an options object" };
   }
-  if (!isRecord9(args.judge)) return { ok: true, compete: { candidates } };
+  if (!isRecord8(args.judge)) return { ok: true, compete: { candidates } };
   const judge = {};
   for (const key of ["agent", "model", "target", "node"]) {
     const value = stringArg(args.judge, key);
@@ -36819,7 +37232,7 @@ function createDispatchAdmissionController(deps) {
           return {
             check: entry.check,
             argv: [...check.command],
-            cwd: resolve8(process.cwd(), check.cwd),
+            cwd: resolve9(process.cwd(), check.cwd),
             timeoutMs: entry.timeoutMs,
             // A judged check seals its kind and absolute file paths here, so
             // host verification judges against what the catalog declared at
@@ -36827,14 +37240,14 @@ function createDispatchAdmissionController(deps) {
             ...check.kind !== "command" ? { kind: check.kind } : {},
             ...check.numeric !== void 0 ? {
               numeric: {
-                reference: resolve8(process.cwd(), check.numeric.reference),
+                reference: resolve9(process.cwd(), check.numeric.reference),
                 tolerance: { ...check.numeric.tolerance }
               }
             } : {},
             ...check.perf !== void 0 ? {
               perf: {
                 ...check.perf.budget !== void 0 ? { budget: structuredClone(check.perf.budget) } : {},
-                ...check.perf.baseline !== void 0 ? { baseline: resolve8(process.cwd(), check.perf.baseline) } : {},
+                ...check.perf.baseline !== void 0 ? { baseline: resolve9(process.cwd(), check.perf.baseline) } : {},
                 ...check.perf.tolerance !== void 0 ? { tolerance: { ...check.perf.tolerance } } : {}
               }
             } : {}
@@ -36899,7 +37312,7 @@ function createDispatchAdmissionController(deps) {
       ...request.worktree === true ? {
         worktree: true,
         apply: request.apply ?? "merge",
-        ...gitCheckoutRoot(resolve8(request.cwd ?? process.cwd())) === null ? {} : { worktreeDestination: gitCheckoutRoot(resolve8(request.cwd ?? process.cwd())) }
+        ...gitCheckoutRoot(resolve9(request.cwd ?? process.cwd())) === null ? {} : { worktreeDestination: gitCheckoutRoot(resolve9(request.cwd ?? process.cwd())) }
       } : {},
       target: resolution.targetId,
       model: resolution.wireModelId,
@@ -37016,7 +37429,7 @@ function createDispatchAdmissionController(deps) {
       }
     }
     if (args.apply_winner !== void 0) {
-      if (!isRecord9(args.apply_winner)) {
+      if (!isRecord8(args.apply_winner)) {
         return shapeRejection(args, "dispatch: apply_winner must be an options object");
       }
       const branch = stringArg(args.apply_winner, "branch");
@@ -37026,7 +37439,7 @@ function createDispatchAdmissionController(deps) {
         return shapeRejection(args, "dispatch: apply_winner.branch must be a clio-coder/compete/<group>/<n> branch");
       }
       try {
-        const cwd = resolve8(stringArg(args.apply_winner, "cwd") ?? process.cwd());
+        const cwd = resolve9(stringArg(args.apply_winner, "cwd") ?? process.cwd());
         return trustExecution(
           markPrepared(
             withResolvedDispatchPlan(args, {
@@ -37062,6 +37475,10 @@ function createDispatchAdmissionController(deps) {
     if (args.writers === 1 && mode !== "parallel") {
       return shapeRejection(args, "dispatch: writers is supported only for parallel dispatch");
     }
+    if (mode === "parallel" && args.writers !== 1) {
+      const conflict = parallelWriterConflict(parsed.requests, deps.getAgentSpecs());
+      if (conflict !== null) return shapeRejection(args, conflict);
+    }
     const parentCheckout = gitCheckoutRoot(process.cwd());
     for (const request of parsed.requests) {
       if (request.worktree !== true) continue;
@@ -37070,9 +37487,9 @@ function createDispatchAdmissionController(deps) {
       const spec = deps.getAgentSpecs().find((candidate) => candidate.id === request.agentId);
       if (spec?.capabilityClass === "read-only") return shapeRejection(args, "worktree_read_only_agent");
       if (request.cwd !== void 0) {
-        const requested = resolve8(request.cwd);
-        const rel = relative8(parentCheckout, requested);
-        if (rel === ".." || rel.startsWith("../") || isAbsolute6(rel)) {
+        const requested = resolve9(request.cwd);
+        const rel = relative9(parentCheckout, requested);
+        if (rel === ".." || rel.startsWith("../") || isAbsolute7(rel)) {
           return shapeRejection(args, "worktree_cwd_outside_checkout");
         }
       }
@@ -37134,6 +37551,7 @@ function createDispatchAdmissionController(deps) {
             resolveTask(
               {
                 agentId: gateDeciderAgentId(reviewResult.review.reviewer),
+                ...base.budget === void 0 ? {} : { budget: base.budget },
                 executionRole: "reviewer",
                 task: renderDispatchReviewerTask(base.task, subject.runId, cycle, base.intent),
                 systemPrompt: REVIEWER_GATE_PROMPT,
@@ -37169,6 +37587,7 @@ function createDispatchAdmissionController(deps) {
           resolveTask(
             {
               agentId: gateDeciderAgentId(compete.judge?.agent),
+              ...base.budget === void 0 ? {} : { budget: base.budget },
               executionRole: "judge",
               task: `Plan-time capability check for the ${compete.candidates}-candidate judge.`,
               systemPrompt: JUDGE_GATE_PROMPT,
@@ -37239,6 +37658,7 @@ function createDispatchAdmissionController(deps) {
         if (council.synthesis === "judge") {
           const judgeRequest = {
             agentId: council.judge?.agent ?? base.agentId,
+            ...base.budget === void 0 ? {} : { budget: base.budget },
             executionRole: "judge",
             task: "Plan-time capability check for council synthesis.",
             systemPrompt: COUNCIL_JUDGE_PROMPT,
@@ -37264,7 +37684,7 @@ function createDispatchAdmissionController(deps) {
       } else {
         for (const [index, request] of parsed.requests.entries()) tasks.push(resolveTask(request, "task", index + 1));
       }
-      const topology = describeDispatchPlan(args).topology;
+      const topology = dispatchPlanTopology(args);
       const planScale = tasks.length > 1 || topology === "compete" || tasks.some((task) => task.node !== "local" || task.failover === "approved");
       if (!planScale) {
         const marked2 = parsed.requests.some((request) => request.intent !== void 0) ? markPrepared(
@@ -37319,24 +37739,13 @@ var FULL_DISPATCH_SCHEMA_COMPOSITION = Object.freeze({
   compete: true,
   adaptiveRouting: true
 });
-function distinctFleetRoutes(fleet) {
-  const routes = /* @__PURE__ */ new Set();
-  const add = (target, model) => {
-    if (!target) return;
-    routes.add(`${target}${model ?? ""}`);
-  };
-  add(fleet.default.target, fleet.default.model);
-  for (const profile of Object.values(fleet.profiles)) add(profile.target, profile.model);
-  for (const roster of Object.values(fleet.rosters)) {
-    for (const member of roster.members) add(member.target, member.model);
-  }
-  return routes.size;
-}
 function dispatchSchemaCompositionFor(fleet) {
   const routing = fleet.adaptiveRouting;
   return {
     council: Object.keys(fleet.rosters).length > 0,
-    compete: distinctFleetRoutes(fleet) > 1,
+    // The runner isolates candidate executions and dispatches a separate judge;
+    // route diversity is not required. Normal admission still validates routes.
+    compete: true,
     adaptiveRouting: routing.roles.length > 0 || routing.postures.length > 0 || routing.agentRoles.length > 0
   };
 }
@@ -37365,7 +37774,7 @@ var DispatchBudgetSchema = typebox_exports.Object(
   },
   {
     additionalProperties: false,
-    description: "Tool-call budget within the recipe's range; retryRevision preauthorizes one ceiling for a retry or revision phase."
+    description: "Advisory tool-call estimate; choose appropriate counts even above recipe recommendations. retryRevision sets a retry/revision estimate. Crossing estimates does not stop work."
   }
 );
 var DispatchVerificationSchema = typebox_exports.Array(
@@ -37395,7 +37804,7 @@ var DispatchIntentSchema = typebox_exports.Object(
   },
   {
     additionalProperties: false,
-    description: "Repository-relative paths and outputs. Declare it on every dispatch: it selects the project rules that apply and pins worker context, where omitting it falls back to path tokens scraped from the task text. verification entries are declared check ids from package scripts or .clio-coder/verifiers.yaml. Per-task intent must fit inside the top-level intent."
+    description: "Repository-relative paths and outputs. Declare it on every dispatch: it selects the project rules that apply and pins worker context, where omitting it falls back to path tokens scraped from the task text. verification entries are declared check ids from package scripts or .clio-coder/verifiers.yaml. Per-task intent fields override inherited top-level fields within its scope. For disjoint parallel writes, set each task's write_roots to only its assigned outputs; expected_outputs alone does not narrow write access."
   }
 );
 var DISPATCH_DEFS = { intent: DispatchIntentSchema, budget: DispatchBudgetSchema };
@@ -37445,14 +37854,25 @@ function buildDispatchParameters(composition = FULL_DISPATCH_SCHEMA_COMPOSITION)
               briefing: typebox_exports.Optional(
                 typebox_exports.String({ description: `Per-task parent context, max ${DISPATCH_BRIEFING_MAX_BYTES} UTF-8 bytes.` })
               ),
-              agent: typebox_exports.Optional(typebox_exports.String({ description: "Recipe id (default coder)." })),
+              agent: typebox_exports.Optional(
+                typebox_exports.String({
+                  description: "Recipe id for this task: set scout/documenter explicitly in a mixed pipeline; names in task text do not select recipes, and omission inherits the batch/default recipe."
+                })
+              ),
               budget: typebox_exports.Optional(BudgetRef),
               target: typebox_exports.Optional(typebox_exports.String()),
               model: typebox_exports.Optional(typebox_exports.String()),
               node: typebox_exports.Optional(typebox_exports.String({ description: "Fleet node pin: local or a fleet.nodes id." })),
               worktree: typebox_exports.Optional(typebox_exports.Literal(true, { description: "Run this writer in an isolated git worktree." })),
               intent: typebox_exports.Optional(IntentRef),
-              gate: typebox_exports.Optional(typebox_exports.String({ description: "One declared check id, shorthand for intent.verification." }))
+              gate: typebox_exports.Optional(typebox_exports.String({ description: "One declared check id, shorthand for intent.verification." })),
+              result_summary_max_bytes: typebox_exports.Optional(
+                typebox_exports.Integer({
+                  minimum: 1,
+                  maximum: RESULT_SUMMARY_MAX_BYTES_CEILING,
+                  description: "This task's inline summary allowance; mutation-report workers (coder, documenter) only."
+                })
+              )
             })
           ]),
           { description: "Batch of assignments; one string or object is wrapped." }
@@ -37529,7 +37949,7 @@ function buildDispatchParameters(composition = FULL_DISPATCH_SCHEMA_COMPOSITION)
       } : {},
       agent: typebox_exports.Optional(
         typebox_exports.String({
-          description: composition.council ? "Default recipe id for string tasks, or auto (default coder; researcher for council)." : "Default recipe id for string tasks, or auto (default coder)."
+          description: composition.council ? "Default recipe id for tasks without their own agent, or auto (default coder; researcher for council)." : "Default recipe id for tasks without their own agent, or auto (default coder)."
         })
       ),
       briefing: typebox_exports.Optional(
@@ -37567,7 +37987,14 @@ function buildDispatchParameters(composition = FULL_DISPATCH_SCHEMA_COMPOSITION)
       thinking_level: typebox_exports.Optional(StringEnum(THINKING_LEVELS2)),
       cwd: typebox_exports.Optional(typebox_exports.String({ description: "Default worker working directory." })),
       timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Abort the dispatch after this many ms." })),
-      max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Max summary bytes returned." }))
+      max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Max summary bytes returned." })),
+      result_summary_max_bytes: typebox_exports.Optional(
+        typebox_exports.Integer({
+          minimum: 1,
+          maximum: RESULT_SUMMARY_MAX_BYTES_CEILING,
+          description: `UTF-8 byte allowance for a mutation-report worker's inline summary (coder, documenter), default 16384. A batch default applies to mutation-report steps only; other steps ignore it. Storage bound, not the returned preview (max_output_bytes).`
+        })
+      )
     },
     { $defs: DISPATCH_DEFS }
   );
@@ -37588,7 +38015,7 @@ function createDispatchTool(inputDeps, surfaceOptions = {}) {
   const admission = createDispatchAdmissionController(deps);
   let runnerPromise = null;
   const loadRunner = () => {
-    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-RJ5I2F2O.js")))();
+    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-FRHD6P2O.js")))();
     return runnerPromise;
   };
   return {
@@ -37656,7 +38083,7 @@ function registerAllTools(registry, deps = {}) {
       ...builtin(
         lazyTool(
           monitorToolSurface,
-          async () => (await import("./monitor-CPNIUULB.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
+          async () => (await import("./monitor-FTJLTKCQ.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
         ),
         {
           path: "src/tools/monitor.ts",
@@ -37666,7 +38093,7 @@ function registerAllTools(registry, deps = {}) {
     });
     registry.register({
       ...builtin(
-        lazyTool(steerToolSurface, async () => (await import("./steer-XA25PSCS.js")).createSteerTool({ dispatch })),
+        lazyTool(steerToolSurface, async () => (await import("./steer-S7D7IKPU.js")).createSteerTool({ dispatch })),
         {
           path: "src/tools/steer.ts",
           scope: "core"
@@ -37678,7 +38105,7 @@ function registerAllTools(registry, deps = {}) {
     const panes = deps.panes;
     registry.register({
       ...builtin(
-        lazyTool(panesToolSurface, async () => (await import("./panes-BOHAEGYC.js")).createPanesTool({ panes })),
+        lazyTool(panesToolSurface, async () => (await import("./panes-7BTYH3XQ.js")).createPanesTool({ panes })),
         { path: "src/tools/panes.ts", scope: "core" }
       )
     });
@@ -38017,7 +38444,7 @@ function agentRoleToolWarnings(providers, settings) {
   }
   return warnings;
 }
-async function resolveCompactionModel(settings, providers) {
+async function resolveCompactionModel(settings, providers, signal) {
   const override = settings.context.compaction.model;
   let targetId = settings.chat.target;
   let wireModelId = settings.chat.model;
@@ -38037,7 +38464,7 @@ async function resolveCompactionModel(settings, providers) {
     wireModelId = selected.ref.model;
   }
   if (!targetId || !wireModelId) return null;
-  await prepareBackgroundModelMetadata(providers, targetId);
+  await prepareBackgroundModelMetadata(providers, targetId, signal);
   const status = providers.list().find((entry) => entry.target.id === targetId);
   if (!status?.available) {
     throw new Error("context.compaction.model target is unavailable; check the selected target with clio-coder targets");
@@ -38074,7 +38501,7 @@ async function resolveCompactionModel(settings, providers) {
   applyModelCapabilityPatch(model, refined.capabilities);
   let apiKey = LOCAL_API_KEY_FALLBACK2;
   if (targetRequiresAuth(route.target, route.runtime)) {
-    const auth = await providers.auth.resolveForTarget(route.target, route.runtime);
+    const auth = await providers.auth.resolveForTarget(route.target, route.runtime, signal ? { signal } : void 0);
     if (!auth.available || !auth.apiKey) {
       throw new Error(
         "context.compaction.model authentication is unavailable; authenticate the selected target with clio-coder auth"
@@ -38147,7 +38574,7 @@ function appendSkillActivationRegistryEvent(session, activation) {
   } catch {
   }
 }
-async function runCompactionFlow(session, settings, providers, instructions, trigger, observability) {
+async function runCompactionFlow(session, settings, providers, instructions, trigger, observability, budget, summarize) {
   const meta = session.current();
   if (!meta) {
     throw new Error("no current session to compact; start one with /new or /resume first");
@@ -38157,8 +38584,11 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   const isOriginCurrent = () => session.current()?.id === meta.id && (session.tree(meta.id).leafId ?? void 0) === activeLeafTurnId;
   const entries = filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId);
   if (entries.length === 0) return null;
+  budget?.signal?.throwIfAborted();
   const systemPrompt = await readCompactionSystemPrompt(settings.context.compaction.systemPrompt, meta.cwd);
-  const resolved = await resolveCompactionModel(settings, providers);
+  budget?.signal?.throwIfAborted();
+  const resolved = await resolveCompactionModel(settings, providers, budget?.signal);
+  budget?.signal?.throwIfAborted();
   if (!resolved) {
     throw new Error("no model configured; set chat.target + chat.model");
   }
@@ -38181,6 +38611,8 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   try {
     result = await compact({
       entries,
+      ...budget,
+      ...summarize ? { summarize } : {},
       onCall: (call) => calls.push(call),
       model: resolved.model,
       ...systemPrompt !== void 0 ? { systemPrompt } : {},
@@ -38198,6 +38630,10 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   } finally {
     releaseEndpointSlot();
   }
+  if (budget?.signal?.aborted) {
+    preserveCalls();
+    budget.signal.throwIfAborted();
+  }
   if (!isOriginCurrent()) {
     preserveCalls();
     throw new Error("compaction session or branch changed; summary discarded and originating usage retained");
@@ -38215,6 +38651,8 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
     turnId: randomUUID3(),
     parentTurnId: result.firstKeptTurnId ?? null,
     summary: result.summary,
+    ...result.skillContext ? { skillContext: result.skillContext } : {},
+    ...result.userContext ? { userContext: result.userContext } : {},
     tokensBefore: result.tokensBefore,
     firstKeptTurnId: result.firstKeptTurnId ?? "",
     messagesSummarized: result.messagesSummarized,
@@ -38243,7 +38681,7 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
 }
 function compactionCheckpointWasWritten(path2, turnId) {
   let malformed = false;
-  for (const line of readFileSync9(path2, "utf8").split("\n")) {
+  for (const line of readFileSync8(path2, "utf8").split("\n")) {
     if (line.trim().length === 0) continue;
     try {
       const entry = JSON.parse(line);
@@ -38256,16 +38694,26 @@ function compactionCheckpointWasWritten(path2, turnId) {
   if (malformed) throw new Error("cannot prove checkpoint absence in a malformed session ledger");
   return false;
 }
-function createProductionAutoCompact(session, getSettings, providers, observability) {
-  return (instructions, trigger) => runCompactionFlow(session, getSettings(), providers, instructions, trigger, observability);
+function createProductionAutoCompact(session, getSettings, providers, observability, summarize) {
+  return (instructions, trigger, budget) => runCompactionFlow(session, getSettings(), providers, instructions, trigger, observability, budget, summarize);
 }
-function estimateTokensFromSummary(summary) {
-  return Math.max(1, ceilChars(summary.length));
+function estimateTokensFromSummary(result) {
+  return estimateTokens({
+    kind: "compactionSummary",
+    turnId: "estimate",
+    parentTurnId: null,
+    timestamp: "",
+    summary: result.summary,
+    firstKeptTurnId: result.firstKeptTurnId ?? "",
+    tokensBefore: result.tokensBefore,
+    ...result.skillContext ? { skillContext: result.skillContext } : {},
+    ...result.userContext ? { userContext: result.userContext } : {}
+  });
 }
 function estimateTokensAfterCompaction(entries, result) {
   let droppedTokens = 0;
   for (const entry of entries.slice(0, result.firstKeptEntryIndex)) droppedTokens += estimateTokens(entry);
-  const summaryTokens = estimateTokensFromSummary(result.summary);
+  const summaryTokens = estimateTokensFromSummary(result);
   return Math.max(summaryTokens, result.tokensBefore - droppedTokens + summaryTokens);
 }
 function advanceScopedTarget(settings, direction) {
@@ -38319,6 +38767,16 @@ async function bootOrchestrator(options = {}) {
   installBusTracer();
   termination.installSignalHandlers();
   ensureClioState();
+  for (const surface of ["safety", "settings"]) {
+    const snapshot = captureProjectSurface(process.cwd(), surface);
+    if (snapshot.verdict === "trusted") continue;
+    for (const file of snapshot.files) {
+      if (file.text !== null || file.error !== void 0) {
+        bootStderr(`[clio-coder:trust] ${projectSurfaceTrustNotice(snapshot, file.path)}
+`);
+      }
+    }
+  }
   sweepExpiredToolOffloads();
   timer.mark("install check");
   if (isGitRepository(process.cwd())) {
@@ -38360,7 +38818,7 @@ async function bootOrchestrator(options = {}) {
   let protectedArtifactStateForDispatch = null;
   const muxInteractive = !options.headless && options.acp === void 0 && process.env.CLIO_CODER_INTERACTIVE === "1";
   const muxEnablement = resolvePanesEnablement(options.panes, options.startupSettings?.interface.panes.enabled);
-  const withPanes = muxInteractive && muxEnablement !== "off" ? await import("./with-panes-BDQEWBRT.js") : null;
+  const withPanes = muxInteractive && muxEnablement !== "off" ? await import("./with-panes-OFTNAR4Y.js") : null;
   const result = await loadDomains(
     [
       options.startupSettings ? createConfigDomainModule(options.startupSettings) : ConfigDomainModule,
@@ -38674,7 +39132,8 @@ async function bootOrchestrator(options = {}) {
   if (contextDomain) {
     middleware.registerHook(createFileMutationObserver(({ paths }) => contextDomain.noteFileChanges(paths)));
   }
-  const hookReceiptLog = createHookReceiptLog({ persistPath: join11(clioStateDir(), "hook-receipts.json") });
+  const hookReceiptLog = createHookReceiptLog({ persistPath: join10(clioStateDir(), "hook-receipts.json") });
+  let bootHookNotices = true;
   const extensionReload = createExtensionReloadCoordinator({
     extensions,
     middleware,
@@ -38683,10 +39142,13 @@ async function bootOrchestrator(options = {}) {
     report: (line) => {
       if (!interactive) process.stderr.write(`${line}
 `);
+      else if (bootHookNotices) initialNotices.push(line);
+      else bus.emit(BusChannels.ExtensionsLoadIssue, { message: line });
     },
     onCommitted: (event) => bus.emit(BusChannels.ExtensionsReloaded, event)
   });
   extensionReload.applyBoot();
+  bootHookNotices = false;
   termination.onDrain(() => hookReceiptLog.flush());
   let activeAcpSessionAutonomy = null;
   const resolveBaselineAutonomy = () => effectiveSettingsForDispatch?.().safety.autonomy ?? options.headless?.autonomy ?? (config?.get() ?? readSettings()).safety.autonomy ?? "auto-edit";
@@ -39487,4 +39949,4 @@ export {
   createBackgroundMemoryRouting,
   createProductionAutoCompact
 };
-//# sourceMappingURL=orchestrator-J4BSH4WQ.js.map
+//# sourceMappingURL=orchestrator-N47O7SFD.js.map