@iowarp/clio-coder 0.5.0 → 0.5.2

package/dist/{orchestrator-DTAPXULA.js → orchestrator-OUW3ZN6Y.js}

@@ -3,30 +3,30 @@ import {
   buildEvictionFields,
   planEviction,
   resolveWorkingSetPolicy
-} from "./chunk-2DTIWSAW.js";
+} from "./chunk-SEQDH6JC.js";
 import {
   projectHeadlessJsonEvent,
   setupSteerChannel
-} from "./chunk-CBAQPTDU.js";
+} from "./chunk-PIU6BXXW.js";
 import {
   ShareDomainModule
-} from "./chunk-IFPDAD7R.js";
+} from "./chunk-RWSRKXLT.js";
 import {
   modelBootstrapGenerate,
   resolveBootstrapRoute
-} from "./chunk-LYJJ6546.js";
+} from "./chunk-3GSPCWFX.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule,
   renderAgentCatalogSectionsFromSpecs
-} from "./chunk-3JLTRPN7.js";
+} from "./chunk-CVMUXT64.js";
 import {
   recordFailedCompactionCalls
-} from "./chunk-D3KWFOUT.js";
+} from "./chunk-23UIXH6Z.js";
 import {
   LifecycleDomainModule,
   describeUpgradeNotice
-} from "./chunk-4VDHLCF5.js";
+} from "./chunk-4WJBWKMI.js";
 import "./chunk-HOYZUKG7.js";
 import "./chunk-QHSBROEW.js";
 import {
@@ -44,12 +44,12 @@ import {
 } from "./chunk-DR3TAEUA.js";
 import {
   steerToolSurface
-} from "./chunk-GCQFN7YI.js";
+} from "./chunk-EMYEQLWO.js";
 import {
   panesToolSurface
-} from "./chunk-ZUKUCZYZ.js";
+} from "./chunk-TQ2KTH4A.js";
 import "./chunk-NASYVWDB.js";
-import "./chunk-IN7DGBVS.js";
+import "./chunk-VLX5VZ35.js";
 import {
   ensureClioState,
   takeUpgradeNotice
@@ -61,11 +61,12 @@ import {
   prewarmPromptTokens,
   recordStartupDiagnostic,
   runPrewarmRound
-} from "./chunk-BFOSV5EZ.js";
+} from "./chunk-WX2YCH7F.js";
 import {
   HANDOFF_RESPONSE_SCHEMA,
   buildModelReplayAgentMessagesFromTurns,
   compact,
+  continuityContextFromSession,
   createAssistantGenerationTiming,
   hasAssistantGenerationDelta,
   rememberRecentModel,
@@ -73,12 +74,12 @@ import {
   renderEvictionSkipLine,
   subscribeLoopGuardStop,
   watchdogBlockersNotice
-} from "./chunk-62UK7AGW.js";
+} from "./chunk-M5PMRZSR.js";
 import {
   DEFAULT_KEEP_RECENT_TOKENS,
   calculateContextTokens,
   estimateTokens
-} from "./chunk-YQ6XEFVK.js";
+} from "./chunk-Z74OGONW.js";
 import {
   assistantSessionPayload,
   attachedToolSchemasFromState,
@@ -110,12 +111,12 @@ import {
   toolNamesFromAgentState,
   toolResultSummary,
   toolSignatureFromState
-} from "./chunk-ZR5YA6ZF.js";
+} from "./chunk-36XVK5P5.js";
 import {
   PROMPT_MANIFEST_VERSION,
   appendPromptCompileRecord,
   readPromptCompileRecords
-} from "./chunk-ZJPORZTC.js";
+} from "./chunk-GIAI7A2K.js";
 import {
   detectPlatformKeybindingWarnings,
   detectTerminalKeySupport,
@@ -125,7 +126,7 @@ import {
 } from "./chunk-3O5JWP4L.js";
 import {
   InteropDomainModule
-} from "./chunk-T2MDZES3.js";
+} from "./chunk-EBMTBE76.js";
 import "./chunk-4A6YRGV4.js";
 import {
   BUILTIN_SLASH_COMMANDS,
@@ -133,7 +134,7 @@ import {
   dispatchSlashCommand,
   isWorkerShareNote,
   parseSlashCommand
-} from "./chunk-3LT34CAM.js";
+} from "./chunk-XBIGUILU.js";
 import {
   bootstrapInputFromInitOptions
 } from "./chunk-DGC6X6XR.js";
@@ -141,32 +142,32 @@ import "./chunk-RFCKPS2V.js";
 import "./chunk-QUIJZSDW.js";
 import {
   AgentsDomainModule
-} from "./chunk-UCINIRHW.js";
-import "./chunk-OJXOA6YU.js";
+} from "./chunk-TPCZXWLT.js";
+import "./chunk-TL6LNERH.js";
 import "./chunk-GGPF6LLE.js";
 import {
   createUserTasksStore
-} from "./chunk-ISHUS7HC.js";
+} from "./chunk-JRW236JT.js";
 import {
   compileScoutTransition
-} from "./chunk-DF6PI6GN.js";
+} from "./chunk-I6UKQPGS.js";
 import {
   monitorToolSurface
-} from "./chunk-B7GY6QER.js";
+} from "./chunk-B26OUMJW.js";
 import {
   ObservabilityDomainModule,
   recordBackgroundMemoryStep
-} from "./chunk-HQVN7G4F.js";
+} from "./chunk-G62JBPXN.js";
 import {
   appendOutOfTurnUsageRow
-} from "./chunk-V35KZDUZ.js";
-import "./chunk-HOEDA42N.js";
-import "./chunk-EG4ARXPC.js";
+} from "./chunk-AA3GRZWS.js";
+import "./chunk-T7HZ7KJF.js";
+import "./chunk-OX6QTA4N.js";
 import {
   foldWorkingSet,
   isTurnStart,
   selectVisibleEntries
-} from "./chunk-EZD2BXGP.js";
+} from "./chunk-GUFQPTQK.js";
 import {
   applyOverrides,
   applyRoutingPatch,
@@ -184,7 +185,7 @@ import {
 import "./chunk-LJRBX7QR.js";
 import {
   createResourcesDomainModule
-} from "./chunk-4WOOTKFD.js";
+} from "./chunk-U3FETNQB.js";
 import "./chunk-Y3JU5RPK.js";
 import "./chunk-6OWUM2NC.js";
 import {
@@ -209,6 +210,7 @@ import {
   ACP_SESSION_META_KEY,
   ACP_TOOL_PROGRESS_META_KEY,
   ACP_USAGE_META_KEY,
+  MEMORY_RELEVANCE_VERSION,
   buildMemoryPromptSection,
   canonicalMemoryRepositoryIdentity,
   createContextDomainModule,
@@ -217,11 +219,11 @@ import {
   createRunReceiptQuality,
   createTaskMemoryTrace,
   endpointCapacityUsage,
-  loadMemoryRecordsSync,
   newRunId,
   openLedger,
   proposeInjectedTaskMemory,
   protectedResidencyModels,
+  readMemoryStoreSnapshot,
   readTaskMemorySpendSummary,
   renderDispatchReviewerTask,
   renderTaskMemoryHandoffSource,
@@ -231,36 +233,42 @@ import {
   taskMemoryBankSize,
   taskMemoryHandoffSeedOffer,
   taskMemoryTracePath
-} from "./chunk-LTWH2ACR.js";
+} from "./chunk-EQPFEDFV.js";
 import "./chunk-PECBKCDK.js";
 import {
   readGateDecisionArtifacts,
   readPendingGateDecisions
-} from "./chunk-OV62D6KO.js";
-import "./chunk-I4ELN5BX.js";
+} from "./chunk-KQMYL5GR.js";
+import "./chunk-ZTNOEJRI.js";
 import {
   isGitRepository,
   recoverCleanupReadyCompeteGroups
-} from "./chunk-DXSETN72.js";
+} from "./chunk-7WUGNN43.js";
 import {
   requireAgentSteps
-} from "./chunk-NFSK2VNU.js";
-import "./chunk-OZ76TLGU.js";
+} from "./chunk-LZMTVVN4.js";
+import "./chunk-EEITU7S6.js";
 import {
   SessionDomainModule,
   addResponseModelIdObservationCounts,
   attributedModelId,
+  continuityProjectionTokens,
+  continuityReplayText,
+  createContinuityPersistencePorts,
   emptyResponseModelIdObservationCounts,
   protectedArtifactEntryFromArtifact,
-  protectedArtifactStateFromSessionEntries
-} from "./chunk-EOJPDNUP.js";
+  protectedArtifactStateFromSessionEntries,
+  resolveContinuityEvidence,
+  resolveContinuityProjection,
+  validateContinuityNote
+} from "./chunk-GPTR6OTU.js";
 import "./chunk-BOBCCDJ6.js";
 import "./chunk-E6IPKW2E.js";
 import {
   SafetyDomainModule,
   parseRigorOverride,
   resolveRigor
-} from "./chunk-XMDBTYCH.js";
+} from "./chunk-N3CWOGVF.js";
 import {
   configureRunEventJournal
 } from "./chunk-UQIVHSE4.js";
@@ -277,16 +285,16 @@ import "./chunk-ZU4JPCPR.js";
 import {
   activeDecisionRefs,
   createDecisionBoardStore
-} from "./chunk-U5QU5ZOD.js";
+} from "./chunk-XYPWFSU5.js";
 import "./chunk-DNHVRBH4.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-O5F25NIE.js";
-import "./chunk-U6YTUVOX.js";
+import "./chunk-Q4RMNWMZ.js";
 import "./chunk-SD7SHNDW.js";
 import {
   discoverDeclaredChecks
-} from "./chunk-7RET77VB.js";
+} from "./chunk-Q2HKY32Y.js";
 import "./chunk-YQ3GFEUY.js";
 import "./chunk-WTQGRBHV.js";
 import "./chunk-GLIQT7SU.js";
@@ -311,17 +319,17 @@ import "./chunk-GM4TY6VN.js";
 import "./chunk-XISLDHEL.js";
 import {
   collectSessionEntries
-} from "./chunk-RNDCROSG.js";
-import "./chunk-5KQEUIWM.js";
-import "./chunk-5JQR5B4D.js";
-import "./chunk-ZARZ4POR.js";
-import "./chunk-UX2L5CUD.js";
+} from "./chunk-CNXU7TR2.js";
+import "./chunk-7LUEQODV.js";
+import "./chunk-6KV4KCQZ.js";
+import "./chunk-G5ZDQQE3.js";
+import "./chunk-AI36V3ON.js";
 import {
   discoverMarketplaceSkills,
   installSkill,
   installedSkillNames,
   modelVisibleSkills
-} from "./chunk-LAR7DX5E.js";
+} from "./chunk-B5TASTCK.js";
 import "./chunk-DNCE23JJ.js";
 import "./chunk-CDQ2UC6W.js";
 import "./chunk-5LP5FNNR.js";
@@ -336,6 +344,7 @@ import {
 import "./chunk-LAVUQX3B.js";
 import {
   INTERACTIVE_LOOP_BLOCK_BUDGET,
+  continueEngineWithoutInput,
   createEngineAgent,
   createLoopGuardRegistration,
   createProtectedArtifactsRegistration,
@@ -350,19 +359,19 @@ import {
   replaceEngineMessages,
   sanitizeLockedSynthesisMessage,
   setEngineSystemPrompt
-} from "./chunk-GRHOXDKB.js";
+} from "./chunk-ELDJWJKM.js";
 import "./chunk-ZNUZ3EXD.js";
 import {
   captureWorkerContext
-} from "./chunk-R7FGRZNF.js";
+} from "./chunk-LXYHCCIZ.js";
 import {
   DEFAULT_RECENT_ENTRY_LIMIT,
   assessFinishContract,
   recentEntries
-} from "./chunk-DOUISWEE.js";
+} from "./chunk-QOJ4ERMU.js";
 import {
   verifyReceiptIntegrity
-} from "./chunk-VKHLUZNO.js";
+} from "./chunk-UZ7YBL43.js";
 import {
   COUNCIL_JUDGE_PROMPT,
   COUNCIL_MAX_MEMBERS,
@@ -428,14 +437,14 @@ import {
   watchdogBriefing,
   withResolvedDispatchPlan,
   writeMiddlewareDiagnosticToStderr
-} from "./chunk-OQ2EOAHA.js";
+} from "./chunk-PF36KOGI.js";
 import {
   createTaskBoardStore
-} from "./chunk-NDPF2N2L.js";
+} from "./chunk-7DW7CJW2.js";
 import "./chunk-7QXCO3AF.js";
 import {
   defaultRoutingIntent
-} from "./chunk-T33IYTZM.js";
+} from "./chunk-SAASVMIY.js";
 import "./chunk-OH3YYA3B.js";
 import "./chunk-VESL6DQY.js";
 import "./chunk-FD3IAHQM.js";
@@ -444,40 +453,41 @@ import {
 } from "./chunk-XNIZBOFV.js";
 import {
   TOOL_PROFILE_NAMES
-} from "./chunk-XZWSP67B.js";
+} from "./chunk-5APYAXCB.js";
 import {
   agentRoleFactsResolver,
   gateDeciderAgentId,
   requestExecutionRole
-} from "./chunk-BRCOSE7O.js";
+} from "./chunk-SZUO5BSE.js";
 import {
   DEFAULT_KILL_GRACE_MS,
   DEFAULT_TEARDOWN_BOUND_MS
-} from "./chunk-55RMDDFM.js";
+} from "./chunk-PGQG7ZMW.js";
 import {
   narrowDispatchIntentToReadOnly,
   normalizeDispatchIntent
 } from "./chunk-L4N3DWNW.js";
-import "./chunk-TDGYTWM6.js";
-import "./chunk-CTFPFW3H.js";
-import "./chunk-DE2LU267.js";
+import "./chunk-F4I3H56H.js";
+import "./chunk-Q6FRR3AQ.js";
+import "./chunk-KKAJGT3B.js";
+import "./chunk-H7REJ7L5.js";
 import "./chunk-YYLCPDCC.js";
 import "./chunk-EFSEIZE6.js";
-import "./chunk-KBUTSJSR.js";
+import "./chunk-4XBYHXGK.js";
 import {
   expandInlineFileReferencesAsync
-} from "./chunk-YBUECLAF.js";
-import "./chunk-CRHPCPZP.js";
-import "./chunk-FFYTC2KQ.js";
-import "./chunk-UJD5MPP6.js";
+} from "./chunk-YEJQDODA.js";
+import "./chunk-4KC4CHKJ.js";
+import "./chunk-MNABNEBX.js";
+import "./chunk-FLNXQQ5B.js";
 import {
   escapeRegExp
 } from "./chunk-DZLR4UEH.js";
 import {
   sweepExpiredToolOffloads,
   toolResultPresentationText
-} from "./chunk-OPD7GL6F.js";
-import "./chunk-733ZBT5P.js";
+} from "./chunk-H6FQVNZC.js";
+import "./chunk-E74MJF6G.js";
 import "./chunk-GHXGMFQ5.js";
 import "./chunk-KECNXMDE.js";
 import "./chunk-WXA2CFJO.js";
@@ -493,6 +503,7 @@ import {
   ProvidersDomainModule,
   applyModelCapabilityPatch,
   declareRuntimeNoticeProducer,
+  estimateInputTokensFromContext,
   firstRuntimeResolutionError,
   gatewayRoutingObservationFromRecord,
   gatewayRoutingObservationLabel,
@@ -516,7 +527,7 @@ import {
   setGlobalDefaultMaxOutputTokens,
   setProtectedModelsProvider,
   withRunOverrides
-} from "./chunk-EYTLV3W3.js";
+} from "./chunk-HTWTORF7.js";
 import "./chunk-MCJKEGHO.js";
 import "./chunk-DVTBERFY.js";
 import {
@@ -544,7 +555,7 @@ import {
   reconcileSnapshot,
   shouldCompact,
   snapshotInputTokens
-} from "./chunk-6W75D37F.js";
+} from "./chunk-53P775GE.js";
 import {
   VALID_THINKING_LEVELS,
   registerBuiltinRuntimes
@@ -577,21 +588,30 @@ import {
   incompleteInstallationAdvice
 } from "./chunk-HMN2C6YL.js";
 import {
+  HANDOFF_MAX_FLUSH_RETRIES,
+  HANDOFF_MAX_WINDOW_MS,
+  HANDOFF_POLICY_LIMITS,
+  HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE,
+  HANDOFF_SCHEMA_VERSION,
   SKILL_CONTEXT_STATE,
-  armedSkillSurface,
+  canonicalJson,
+  isContinuityCheckpointPayload,
   isSessionEntry,
-  isSkillActivation,
   latestSkillContextState,
-  mainSkillContextState,
-  skillActivationFromToolDetails,
-  skillSurfaceLabels,
-  skillSurfaceNames,
-  withModelSkillActivation
-} from "./chunk-I4Y4WKZR.js";
+  mainSkillContextState
+} from "./chunk-F6KCJO3U.js";
 import {
   DEFAULT_AUTONOMY_LEVEL,
   modelMayActivateSkills
 } from "./chunk-UZVYEF57.js";
+import {
+  armedSkillSurface,
+  isSkillActivation,
+  skillActivationFromToolDetails,
+  skillSurfaceLabels,
+  skillSurfaceNames,
+  withModelSkillActivation
+} from "./chunk-MMZMM6SW.js";
 import "./chunk-O3VV6IVK.js";
 import {
   atomicWrite,
@@ -600,20 +620,20 @@ import {
   readSessionTailTurns,
   sessionCurrentPath,
   sessionPaths
-} from "./chunk-EKV4UBCM.js";
+} from "./chunk-PZBQUJ2F.js";
 import "./chunk-UHW5V7HC.js";
 import {
   RESULT_SUMMARY_MAX_BYTES_CEILING,
   parseScoutResult,
   parseVerifierResult,
   resultContractSourceId
-} from "./chunk-LNOXCGN2.js";
+} from "./chunk-7UFDIOBT.js";
 import "./chunk-BJH6WFIB.js";
 import "./chunk-5EQO5NWP.js";
-import "./chunk-VYRQHORQ.js";
+import "./chunk-NMQSO6Z6.js";
 import {
   toolMutationPaths
-} from "./chunk-P4GNZPXO.js";
+} from "./chunk-OYUS3UZP.js";
 import "./chunk-R2P2U3ZS.js";
 import "./chunk-NTTS3O53.js";
 import "./chunk-C2CPOIH2.js";
@@ -625,7 +645,7 @@ import {
 } from "./chunk-M4KFUXS7.js";
 import {
   ToolNames
-} from "./chunk-V4XJWDHR.js";
+} from "./chunk-6UKFRTXI.js";
 import {
   readSettings,
   updateSettings
@@ -700,7 +720,7 @@ import {
 
 // src/entry/orchestrator.ts
 init_esm_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
 
@@ -1386,6 +1406,65 @@ function stableJson(value) {
   return JSON.stringify(value);
 }
 
+// src/domains/memory/prompt-cache.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+function createMemoryPromptReader(options) {
+  const selection = { ...options.selection, scopes: [...options.selection?.scopes ?? ["global", "repo", "runtime"]] };
+  const experimentalRelevance = options.experimentalRelevance === true;
+  const readStore = options.readStore ?? readMemoryStoreSnapshot;
+  let frame = null;
+  let selected = null;
+  return (request) => {
+    const dataDir = options.getDataDir();
+    const activeRepository = canonicalMemoryRepositoryIdentity(request.cwd);
+    const authority = JSON.stringify([
+      dataDir,
+      request.sessionAuthority,
+      request.cwd,
+      activeRepository,
+      request.targetId,
+      request.runtimeId,
+      request.modelId
+    ]);
+    const frameKey = JSON.stringify([request.turnId, authority]);
+    if (request.turnId !== null && frame?.key === frameKey) return frame.section;
+    let section = "";
+    try {
+      const snapshot = readStore(dataDir);
+      const relevance = {
+        taskText: request.taskText,
+        activePaths: [...request.activePaths],
+        activeSymbols: [...request.activeSymbols ?? []]
+      };
+      const key = createHash("sha256").update(
+        JSON.stringify([
+          snapshot.revision,
+          authority,
+          selection,
+          relevance,
+          experimentalRelevance,
+          MEMORY_RELEVANCE_VERSION
+        ])
+      ).digest("hex");
+      if (selected?.key === key) section = selected.section;
+      else {
+        section = buildMemoryPromptSection(snapshot.records, {
+          ...selection,
+          activeRepository,
+          activeRuntime: { kind: "runtime", key: request.runtimeId },
+          ...experimentalRelevance ? { relevance } : {}
+        }).section;
+        selected = Object.freeze({ key, section });
+      }
+    } catch {
+      selected = null;
+    }
+    frame = request.turnId === null ? null : Object.freeze({ key: frameKey, section });
+    return section;
+  };
+}
+
 // src/domains/middleware/demo-guidance.ts
 init_esm_shims();
 function createDemoGuidanceRegistration(enabled) {
@@ -1498,13 +1577,29 @@ function recordDecision(options, turnId, assessment, rigor) {
   }
 }
 
+// src/domains/session/continuity/carry.ts
+init_esm_shims();
+function continuityPayloadFromFold(fold) {
+  if (!fold.validated) return null;
+  if (!fold.identity || !fold.accepted || !fold.policy || !fold.commit || !fold.state) return null;
+  const payload = {
+    schemaVersion: HANDOFF_SCHEMA_VERSION,
+    identity: fold.identity,
+    accepted: fold.accepted,
+    policy: fold.policy,
+    commit: fold.commit,
+    state: fold.state
+  };
+  return isContinuityCheckpointPayload(payload) ? payload : null;
+}
+
 // src/domains/session/protected-artifact-journal.ts
 init_esm_shims();
-import { createHash, randomBytes } from "node:crypto";
+import { createHash as createHash2, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 function sessionKey(sessionId) {
-  return createHash("sha256").update(sessionId, "utf8").digest("hex");
+  return createHash2("sha256").update(sessionId, "utf8").digest("hex");
 }
 function journalDirectory(sessionId) {
   return join(clioStateDir(), "protected-artifact-pending", sessionKey(sessionId));
@@ -1537,7 +1632,7 @@ function recordPayload(record2, legacyNaming = false) {
   };
 }
 function digest(record2, legacyNaming = false) {
-  return createHash("sha256").update(JSON.stringify(recordPayload(record2, legacyNaming)), "utf8").digest("hex");
+  return createHash2("sha256").update(JSON.stringify(recordPayload(record2, legacyNaming)), "utf8").digest("hex");
 }
 function withoutIntegrity(record2) {
   return {
@@ -2001,7 +2096,7 @@ function headlessContext(host, notice, push) {
     listAgents: () => unreachable("listAgents"),
     listDelegationAgents: () => unreachable("listDelegationAgents"),
     shutdown: () => unreachable("shutdown"),
-    openCost: () => unreachable("openCost"),
+    openUsage: () => unreachable("openUsage"),
     openSideQuestion: () => unreachable("openSideQuestion"),
     startHandoff: () => unreachable("startHandoff"),
     openContextView: () => unreachable("openContextView"),
@@ -4216,8 +4311,689 @@ function promptResponse(stopReason, active) {
 
 // src/interactive/chat-loop.ts
 init_esm_shims();
+
+// src/interactive/continuity-controller.ts
+init_esm_shims();
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/domains/session/continuity/persistence.ts
+init_esm_shims();
+function continuityRecordDigest(entry) {
+  return canonicalJson(entry);
+}
+function blocked(reason, accepted, barrierAttempts, anomalies) {
+  return { status: "uncertain", reason, accepted: [...accepted], barrierAttempts, anomalies };
+}
+function readback(entry, ports) {
+  try {
+    return ports.readExact(entry);
+  } catch (error) {
+    return { status: "unresolved", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+function reconcileContinuityEntry(entry, ports) {
+  const result = readback(entry, ports);
+  if (result.status === "matching") return { status: "accepted" };
+  if (result.status === "conflicting") {
+    return { status: "conflicting", ...result.detail === void 0 ? {} : { detail: result.detail } };
+  }
+  if (result.status === "unresolved") {
+    return { status: "unresolved", ...result.detail === void 0 ? {} : { detail: result.detail } };
+  }
+  return { status: "absent" };
+}
+function invalidSchedule(retry) {
+  if (!Number.isSafeInteger(retry.limit) || retry.limit < 0 || retry.limit > HANDOFF_MAX_FLUSH_RETRIES) {
+    return `retry limit ${retry.limit} is not an integer in 0..${HANDOFF_MAX_FLUSH_RETRIES}`;
+  }
+  if (!Number.isFinite(retry.deadlineAtMs)) return "retry deadline is not finite";
+  const now = retry.now();
+  if (!Number.isFinite(now)) return "retry clock is not finite";
+  return null;
+}
+function createClockGuard(retry) {
+  let observed = Number.NEGATIVE_INFINITY;
+  let broken = false;
+  return {
+    read() {
+      if (broken) return null;
+      const now = retry.now();
+      if (!Number.isFinite(now) || now < observed) {
+        broken = true;
+        return null;
+      }
+      observed = now;
+      return now;
+    }
+  };
+}
+async function runBarrier(request, ports, retry, clock) {
+  const flushing = request.barrier.kind === "flush";
+  const port = flushing ? ports.flushAppends : ports.checkpoint;
+  if (!port) {
+    return {
+      ok: false,
+      attempts: 0,
+      reason: "unsupported_barrier_port",
+      detail: `${request.barrier.kind} port is not available`
+    };
+  }
+  let attempts = 0;
+  let detail = "";
+  for (let round = 0; round <= retry.limit; round += 1) {
+    let before = clock.read();
+    if (round > 0) {
+      if (before === null || before >= retry.deadlineAtMs) break;
+      try {
+        await retry.wait(round);
+      } catch (error) {
+        return {
+          ok: false,
+          attempts,
+          reason: "barrier_failed",
+          detail: `retry wait rejected: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+      before = clock.read();
+      if (before === null) {
+        return { ok: false, attempts, reason: "invalid_retry_schedule", detail: "retry clock became unusable" };
+      }
+      if (ports.isStateRemoved()) return { ok: false, attempts, reason: "state_removed", detail: "state removed" };
+      if (!ports.isOriginCurrent()) return { ok: false, attempts, reason: "origin_changed", detail: "origin changed" };
+      if (before >= retry.deadlineAtMs) break;
+    }
+    attempts += 1;
+    try {
+      if (request.barrier.kind === "flush") {
+        port();
+      } else {
+        await port(request.barrier.reason);
+      }
+      const after = clock.read();
+      return {
+        ok: true,
+        attempts,
+        confirmedWithinDeadline: before !== null && after !== null && after < retry.deadlineAtMs
+      };
+    } catch (error) {
+      detail = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return { ok: false, attempts, reason: "barrier_failed", detail: detail || "deadline reached before the barrier ran" };
+}
+async function persistContinuityGroup(request, ports, retry) {
+  const anomalies = [];
+  const accepted = [];
+  const wanted = /* @__PURE__ */ new Map();
+  for (const entry of request.entries) {
+    const digest2 = continuityRecordDigest(entry);
+    const previous = wanted.get(entry.turnId);
+    if (previous !== void 0 && previous !== digest2) {
+      anomalies.push({
+        kind: "duplicate_conflict",
+        entryId: entry.turnId,
+        detail: "the group contains two different records under one entry id"
+      });
+      return blocked("duplicate_group_entry", accepted, 0, anomalies);
+    }
+    wanted.set(entry.turnId, digest2);
+  }
+  const acceptedIds = /* @__PURE__ */ new Set();
+  for (const progress of request.alreadyAccepted ?? []) {
+    const expected = wanted.get(progress.entryId);
+    if (expected === void 0 || expected !== progress.payloadDigest) {
+      anomalies.push({
+        kind: "duplicate_conflict",
+        entryId: progress.entryId,
+        detail: "reported progress does not match this group's record for that id"
+      });
+      return blocked("progress_mismatch", [], 0, anomalies);
+    }
+    if (acceptedIds.has(progress.entryId)) continue;
+    acceptedIds.add(progress.entryId);
+    accepted.push({ entryId: progress.entryId, payloadDigest: progress.payloadDigest });
+  }
+  const scheduleProblem = invalidSchedule(retry);
+  if (scheduleProblem) {
+    anomalies.push({ kind: "malformed_record", entryId: null, detail: scheduleProblem });
+    return blocked("invalid_retry_schedule", accepted, 0, anomalies);
+  }
+  const clock = createClockGuard(retry);
+  const remaining = () => request.entries.filter((entry) => !acceptedIds.has(entry.turnId));
+  const startedAt = clock.read();
+  if (startedAt === null) {
+    anomalies.push({ kind: "malformed_record", entryId: null, detail: "the retry clock is not usable" });
+    return blocked("invalid_retry_schedule", accepted, 0, anomalies);
+  }
+  if (startedAt >= retry.deadlineAtMs && remaining().length > 0) {
+    anomalies.push({
+      kind: "malformed_record",
+      entryId: null,
+      detail: "the deadline passed before the group was written"
+    });
+    return blocked("deadline_expired", accepted, 0, anomalies);
+  }
+  if (ports.isStateRemoved()) return blocked("state_removed", accepted, 0, anomalies);
+  if (!ports.isOriginCurrent()) return blocked("origin_changed", accepted, 0, anomalies);
+  const writeBlocked = () => {
+    const now = clock.read();
+    if (now === null) return "invalid_retry_schedule";
+    if (now >= retry.deadlineAtMs) return "deadline_expired";
+    if (ports.isStateRemoved()) return "state_removed";
+    if (!ports.isOriginCurrent()) return "origin_changed";
+    return null;
+  };
+  for (const entry of request.entries) {
+    if (acceptedIds.has(entry.turnId)) continue;
+    const guard = writeBlocked();
+    if (guard) {
+      anomalies.push({ kind: "malformed_record", entryId: entry.turnId, detail: `write refused: ${guard}` });
+      return blocked(guard, accepted, 0, anomalies);
+    }
+    const digest2 = continuityRecordDigest(entry);
+    const accept = () => {
+      accepted.push({ entryId: entry.turnId, payloadDigest: digest2 });
+      acceptedIds.add(entry.turnId);
+    };
+    try {
+      ports.append(entry);
+      accept();
+      continue;
+    } catch (error) {
+      anomalies.push({
+        kind: "malformed_record",
+        entryId: entry.turnId,
+        detail: `append threw: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+    const reconciled = reconcileContinuityEntry(entry, ports);
+    if (reconciled.status === "accepted") {
+      accept();
+      continue;
+    }
+    if (reconciled.status === "conflicting") {
+      anomalies.push({
+        kind: "duplicate_conflict",
+        entryId: entry.turnId,
+        detail: reconciled.detail ?? "stored record has this id and different payload"
+      });
+      return blocked("append_conflicting", accepted, 0, anomalies);
+    }
+    if (reconciled.status === "unresolved") {
+      return blocked("append_unresolved", accepted, 0, anomalies);
+    }
+    const reguard = writeBlocked();
+    if (reguard) {
+      anomalies.push({ kind: "malformed_record", entryId: entry.turnId, detail: `reappend refused: ${reguard}` });
+      return blocked(reguard, accepted, 0, anomalies);
+    }
+    try {
+      ports.append(entry);
+      accept();
+    } catch (error) {
+      const second = reconcileContinuityEntry(entry, ports);
+      if (second.status === "accepted") {
+        accept();
+        continue;
+      }
+      anomalies.push({
+        kind: "malformed_record",
+        entryId: entry.turnId,
+        detail: `reappend threw: ${error instanceof Error ? error.message : String(error)}`
+      });
+      return blocked(
+        second.status === "absent" ? "append_absent_after_retry" : "append_unresolved",
+        accepted,
+        0,
+        anomalies
+      );
+    }
+  }
+  if (ports.isStateRemoved()) return blocked("state_removed", accepted, 0, anomalies);
+  if (!ports.isOriginCurrent()) return blocked("origin_changed", accepted, 0, anomalies);
+  const barrier = await runBarrier(request, ports, retry, clock);
+  if (!barrier.ok) {
+    anomalies.push({
+      kind: "malformed_record",
+      entryId: null,
+      detail: `${request.barrier.kind} barrier did not complete: ${barrier.detail}`
+    });
+    return blocked(barrier.reason, accepted, barrier.attempts, anomalies);
+  }
+  if (ports.isStateRemoved()) return blocked("state_removed", accepted, barrier.attempts, anomalies);
+  if (!ports.isOriginCurrent()) return blocked("origin_changed", accepted, barrier.attempts, anomalies);
+  return {
+    status: "durable",
+    accepted,
+    barrierAttempts: barrier.attempts,
+    confirmedWithinDeadline: barrier.confirmedWithinDeadline
+  };
+}
+
+// src/interactive/continuity-controller.ts
+var ContinuityController = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? Date.now;
+    this.id = deps.id ?? randomUUID2;
+  }
+  deps;
+  live = null;
+  busy = false;
+  now;
+  id;
+  armDeadline(live) {
+    live.deadlineTimer = setTimeout(
+      () => live.abort.abort(new Error("Handoff automatic deadline expired.")),
+      Math.max(1, live.deadline - this.now())
+    );
+    live.deadlineTimer.unref?.();
+  }
+  fold(live = this.live) {
+    if (!live?.origin.ports.isOriginCurrent() || live.origin.ports.isStateRemoved()) return null;
+    return resolveContinuityProjection({
+      entries: this.deps.entries(),
+      sessionId: live.origin.sessionId,
+      nowMs: this.now()
+    }).current;
+  }
+  check(live) {
+    live.abort.signal.throwIfAborted();
+    if (this.live !== live || !live.origin.ports.isOriginCurrent()) throw new Error("Handoff ownership changed.");
+    if (live.uncertain) throw new Error("Handoff persistence is unresolved; inspect before recovery.");
+    if (this.now() >= live.deadline) throw new Error("Handoff automatic deadline expired.");
+  }
+  async persist(live, entries, checkpoint = false, closing = false) {
+    const result = await persistContinuityGroup(
+      {
+        entries: entries.map((entry) => ({ ...entry })),
+        barrier: checkpoint ? { kind: "checkpoint", reason: "context-handoff" } : { kind: "flush" }
+      },
+      live.origin.ports,
+      {
+        limit: live.policy.flushRetryLimit,
+        deadlineAtMs: closing ? this.now() + 5e3 : live.deadline,
+        now: this.now,
+        wait: async () => {
+        }
+      }
+    );
+    if (result.status !== "durable" || !result.confirmedWithinDeadline) {
+      live.uncertain = true;
+      throw new Error(
+        `Handoff durability unresolved: ${result.status === "durable" ? "deadline expired" : result.reason}`
+      );
+    }
+  }
+  async transition(live, event, closing = false) {
+    const fold = this.fold(live);
+    if (!fold?.validated || fold.identity?.handoffId !== live.identity.handoffId || !fold.state)
+      throw new Error("Handoff head cannot be validated.");
+    const entryId = this.id();
+    const entry = {
+      kind: "handoffTransaction",
+      schemaVersion: 1,
+      turnId: entryId,
+      parentTurnId: live.identity.branchAnchorTurnId,
+      timestamp: new Date(this.now()).toISOString(),
+      identity: live.identity,
+      transition: {
+        entryId,
+        prevEntryId: fold.state.transition.entryId,
+        sequence: fold.state.transition.sequence + 1,
+        attempt: fold.attemptsSpent + (event.phase === "reducing" ? 1 : 0)
+      },
+      event
+    };
+    await this.persist(live, [entry], false, closing);
+    if (!this.fold(live)?.validated) throw new Error("Persisted handoff transition failed validation.");
+  }
+  async request(note, toolCallId, signal) {
+    const validation = validateContinuityNote(note);
+    if (!validation.ok) throw new Error(`Invalid handoff note: ${validation.reason}`);
+    if (!toolCallId || this.busy || this.live)
+      throw new Error("A context handoff is already pending or no tool identity was supplied.");
+    signal?.throwIfAborted();
+    const origin = this.deps.captureOrigin();
+    if (origin.ports.isStateRemoved() || !origin.ports.isOriginCurrent())
+      throw new Error("The originating session is unavailable.");
+    if (!this.deps.admitNote(validation.accepted))
+      throw new Error("Exact handoff note and protected context exceed the replay budget.");
+    const prior = resolveContinuityProjection({
+      entries: this.deps.entries(),
+      sessionId: origin.sessionId,
+      nowMs: this.now()
+    }).current;
+    if (prior && prior.phase !== "absent" && prior.phase !== "acknowledged")
+      throw new Error("An earlier handoff requires operator recovery.");
+    const preparedAtMs = this.now();
+    const policy = {
+      ...HANDOFF_POLICY_LIMITS,
+      preparedAtMs,
+      automaticDeadlineAtMs: preparedAtMs + HANDOFF_MAX_WINDOW_MS
+    };
+    const identity = {
+      handoffId: this.id(),
+      preparedEntryId: this.id(),
+      commitId: this.id(),
+      commitEntryId: this.id(),
+      originSessionId: origin.sessionId,
+      branchAnchorTurnId: origin.leafTurnId,
+      initiatingTurnId: origin.initiatingTurnId,
+      toolCallId,
+      sourceRevision: origin.sourceRevision
+    };
+    const live = {
+      origin,
+      identity,
+      accepted: validation.accepted,
+      policy,
+      deadline: policy.automaticDeadlineAtMs,
+      abort: new AbortController(),
+      uncertain: false
+    };
+    this.live = live;
+    this.armDeadline(live);
+    const entry = {
+      kind: "handoffTransaction",
+      schemaVersion: 1,
+      turnId: identity.preparedEntryId,
+      parentTurnId: identity.branchAnchorTurnId,
+      timestamp: new Date(preparedAtMs).toISOString(),
+      identity,
+      transition: { entryId: identity.preparedEntryId, prevEntryId: null, sequence: 0, attempt: 0 },
+      event: { phase: "prepared", accepted: live.accepted, policy }
+    };
+    try {
+      await this.persist(live, [entry]);
+      signal?.throwIfAborted();
+      this.check(live);
+      return `Context handoff ${identity.handoffId} prepared. The exact note is saved. Reduction and continuation follow after this tool receipt is persisted.`;
+    } catch (error) {
+      await this.pause();
+      throw error;
+    }
+  }
+  readyPayload(live, outcome, before, after, ref) {
+    this.check(live);
+    const fold = this.fold(live);
+    if (!fold?.validated || fold.phase !== "reducing" || !fold.state)
+      throw new Error("No durable reduction attempt owns this checkpoint.");
+    const transition = {
+      entryId: live.identity.commitEntryId,
+      prevEntryId: fold.state.transition.entryId,
+      sequence: fold.state.transition.sequence + 1,
+      attempt: fold.attemptsSpent
+    };
+    return {
+      schemaVersion: 1,
+      identity: live.identity,
+      accepted: live.accepted,
+      policy: live.policy,
+      commit: {
+        outcome,
+        entry: {
+          turnId: live.identity.commitEntryId,
+          parentTurnId: live.identity.branchAnchorTurnId,
+          timestamp: new Date(this.now()).toISOString()
+        },
+        transition,
+        tokensBefore: before,
+        tokensAfter: after,
+        ...outcome === "summarized" ? { summaryRef: ref ?? "" } : outcome === "evicted" ? { evictionRef: ref ?? "" } : {}
+      },
+      state: { transition, event: { phase: "ready" }, activeResume: fold.state.activeResume, delivery: null }
+    };
+  }
+  /** Called only at the settled engine boundary, after awaited result persistence. */
+  async settle(signal, recovery = false) {
+    const live = this.live;
+    if (!live || this.busy || live.deliveryId) return false;
+    this.busy = true;
+    const onAbort = () => live.abort.abort(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      if (signal?.aborted) onAbort();
+      this.check(live);
+      const fold = this.fold(live);
+      if (!fold?.validated) throw new Error("Handoff evidence is unresolved.");
+      if (!recovery) {
+        const entries = this.deps.entries();
+        const preparedIndex = entries.findIndex((entry) => entry.turnId === live.identity.preparedEntryId);
+        const receipt = preparedIndex >= 0 && entries.slice(preparedIndex + 1).some((entry) => {
+          if (entry.kind !== "message" || entry.role !== "tool_result") return false;
+          const payload = entry.payload;
+          return entry.parentTurnId === live.origin.leafTurnId && payload.toolCallId === live.identity.toolCallId && payload.toolName === "self_compact" && payload.isError === false;
+        });
+        if (!receipt) throw new Error("Matching successful handoff receipt has not been persisted.");
+      }
+      await this.persist(live, []);
+      this.check(live);
+      if (!fold.commit) {
+        if (fold.attemptsSpent >= live.policy.maxAttempts) throw new Error("Handoff reduction attempts exhausted.");
+        const resumeRef2 = fold.state?.activeResume?.entryId;
+        await this.transition(live, { phase: "reducing", ...resumeRef2 ? { resumeRef: resumeRef2 } : {} });
+        const before = this.deps.inputTokens();
+        const priorIds = new Set(this.deps.entries().map((entry) => entry.turnId));
+        let payload;
+        let calls = 0;
+        await this.deps.reduce(
+          {
+            beforeSummaryCall: () => {
+              this.check(live);
+              if (++calls > live.policy.maxSummaryCallsPerAttempt)
+                throw new Error("Handoff summary invocation limit reached.");
+            },
+            checkpointForSummary: (ref, tokensBefore, tokensAfter) => {
+              payload = this.readyPayload(live, "summarized", tokensBefore, tokensAfter, ref);
+              return payload;
+            }
+          },
+          live.abort.signal
+        );
+        this.check(live);
+        if (!payload) {
+          this.deps.installReplay();
+          if (!this.deps.fits()) throw new Error("Context remains unsafe after reduction; the exact note is retained.");
+          const eviction = [...this.deps.entries()].reverse().find((entry) => entry.kind === "contextEviction" && !priorIds.has(entry.turnId));
+          payload = this.readyPayload(
+            live,
+            eviction ? "evicted" : "continuity_only",
+            before,
+            this.deps.inputTokens(),
+            eviction?.turnId
+          );
+        }
+        await this.persist(
+          live,
+          [
+            {
+              kind: "continuityCommit",
+              ...payload.commit.entry,
+              continuity: { ...payload, state: { ...payload.state, activeResume: null } }
+            }
+          ],
+          true
+        );
+        this.check(live);
+        if (!this.fold(live)?.validated) throw new Error("Handoff checkpoint cannot be validated.");
+        this.deps.onCommit?.(live.identity.commitId, payload.commit.outcome);
+      }
+      this.deps.installReplay();
+      if (!this.deps.fits()) throw new Error("Compacted continuation exceeds the request budget.");
+      this.check(live);
+      const continuationTurnId = this.deps.leaf();
+      if (!continuationTurnId) throw new Error("Continuation has no persisted message anchor.");
+      const deliveryId = this.id();
+      const deliveryFold = this.fold(live);
+      const resumeRef = deliveryFold?.phase === "resumed" ? deliveryFold.state?.activeResume?.entryId : void 0;
+      await this.transition(live, {
+        phase: "delivered",
+        deliveryId,
+        continuationTurnId,
+        ...resumeRef ? { resumeRef } : {}
+      });
+      this.check(live);
+      live.deliveryId = deliveryId;
+      return true;
+    } catch (error) {
+      await this.pause();
+      throw error;
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      this.busy = false;
+    }
+  }
+  /** Synchronous final provider boundary, including steering drained after prepare. */
+  admission() {
+    const live = this.live;
+    if (!live) return { block: false };
+    try {
+      this.check(live);
+      if (!live.deliveryId) throw new Error("Context handoff has not durably reached delivery.");
+      return { block: false, correlationId: live.deliveryId };
+    } catch (error) {
+      return { block: true, reason: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async response(entryId, correlationId) {
+    const live = this.live;
+    if (!live || !entryId || !correlationId || correlationId !== live.deliveryId || live.abort.signal.aborted || !live.origin.ports.isOriginCurrent())
+      return;
+    this.check(live);
+    const evidence = resolveContinuityEvidence({
+      entries: this.deps.entries(),
+      unreadableRecords: 0
+    }).terminalResponses.find((row) => row.entryId === entryId);
+    if (evidence?.status !== "success") return;
+    await this.transition(live, { phase: "acknowledged", deliveryId: correlationId, terminalResponseEntryId: entryId });
+    if (live.deadlineTimer) clearTimeout(live.deadlineTimer);
+    this.live = null;
+  }
+  cancel() {
+    this.live?.abort.abort(new Error("Operator cancelled the context handoff."));
+  }
+  async pause() {
+    const live = this.live;
+    if (!live) return;
+    live.abort.abort();
+    if (live.deadlineTimer) clearTimeout(live.deadlineTimer);
+    try {
+      const fold = this.fold(live);
+      if (!live.uncertain && fold?.validated && ["prepared", "reducing", "ready", "delivered", "resumed"].includes(fold.phase)) {
+        await this.transition(
+          live,
+          { phase: "paused", reason: live.deliveryId ? "delivery_uncertain" : "operator_cancelled" },
+          true
+        );
+      }
+    } catch (error) {
+      this.deps.notice(`Handoff ${live.identity.handoffId}: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      if (this.live === live) this.live = null;
+    }
+  }
+  /** Host-only operator action; never reachable through tool arguments. */
+  async recover(handoffId, action) {
+    if (this.live || this.busy) throw new Error("A handoff is already active.");
+    const origin = this.deps.captureOrigin();
+    let fold = resolveContinuityProjection({
+      entries: this.deps.entries(),
+      sessionId: origin.sessionId,
+      nowMs: this.now()
+    }).current;
+    if (!fold?.validated || fold.identity?.handoffId !== handoffId || !fold.accepted || !fold.policy || !fold.state)
+      throw new Error("No validated handoff matches that identity on this branch.");
+    if (["prepared", "reducing", "ready", "delivered", "resumed"].includes(fold.phase)) {
+      this.live = {
+        origin,
+        identity: fold.identity,
+        accepted: fold.accepted,
+        policy: fold.policy,
+        deadline: this.now() + HANDOFF_MAX_WINDOW_MS,
+        abort: new AbortController(),
+        uncertain: false
+      };
+      if (fold.missingCommit) {
+        const expected = { ...fold.missingCommit.entry };
+        const readback2 = origin.ports.readExact(expected);
+        if (readback2.status !== "absent" && readback2.status !== "matching") {
+          this.live = null;
+          throw new Error("Commit reconstruction is unresolved.");
+        }
+        await this.persist(this.live, readback2.status === "absent" ? [expected] : [], true);
+      }
+      await this.pause();
+      fold = resolveContinuityProjection({
+        entries: this.deps.entries(),
+        sessionId: origin.sessionId,
+        nowMs: this.now()
+      }).current;
+      if (!fold?.validated || !fold.identity || !fold.accepted || !fold.policy || !fold.state)
+        throw new Error("Interrupted handoff could not be paused durably.");
+    }
+    if (!["paused", "failed"].includes(fold.phase))
+      throw new Error("Only a paused or failed handoff accepts operator recovery.");
+    if (action === "reduce" ? fold.commit !== null || fold.attemptsSpent >= fold.policy.maxAttempts : fold.commit === null)
+      throw new Error("That recovery action is unavailable for this handoff.");
+    const now = this.now();
+    const live = {
+      origin,
+      identity: fold.identity,
+      accepted: fold.accepted,
+      policy: fold.policy,
+      deadline: now + HANDOFF_MAX_WINDOW_MS,
+      abort: new AbortController(),
+      uncertain: false
+    };
+    this.live = live;
+    this.armDeadline(live);
+    const request = {
+      kind: "custom",
+      customType: HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE,
+      turnId: this.id(),
+      parentTurnId: origin.leafTurnId,
+      timestamp: new Date(now).toISOString(),
+      display: false,
+      data: {
+        version: 1,
+        requestKind: "handoff_recovery",
+        handoffId,
+        action,
+        sessionId: origin.sessionId,
+        branchAnchorTurnId: fold.identity.branchAnchorTurnId,
+        selectedLeafTurnId: origin.leafTurnId,
+        pausedOrFailedEntryId: fold.state.transition.entryId
+      }
+    };
+    try {
+      await this.persist(live, [request]);
+      await this.transition(live, {
+        phase: "resumed",
+        authority: {
+          operatorRequestEntryId: request.turnId,
+          pausedOrFailedEntryId: fold.state.transition.entryId,
+          action,
+          automaticDeadlineAtMs: live.deadline
+        }
+      });
+      await this.settle(void 0, true);
+    } catch (error) {
+      await this.pause();
+      throw error;
+    }
+  }
+};
+
+// src/interactive/chat-loop.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 
+// src/domains/context/budget/request-fit.ts
+init_esm_shims();
+function requestFits(input, output, window) {
+  return input !== null && output !== null && window !== null && Number.isFinite(input) && input >= 0 && Number.isFinite(output) && output >= 0 && Number.isFinite(window) && window > 0 && input + output <= window;
+}
+
 // src/domains/session/retry.ts
 init_esm_shims();
 import { performance as performance2 } from "node:perf_hooks";
@@ -4467,7 +5243,323 @@ Extract the handoff record for that goal now.`
 
 // src/interactive/turn-context.ts
 init_esm_shims();
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
+
+// src/domains/context/budget/live-view.ts
+init_esm_shims();
+import { createHash as createHash3 } from "node:crypto";
+
+// src/domains/context/budget/pressure.ts
+init_esm_shims();
+var DEFAULT_REDUCE_THRESHOLD = 0.8;
+var DEFAULT_WORKING_SET_TARGET = 0.6;
+var NOTICE_PROPORTION = 0.65 / 0.8;
+var PREPARE_PROPORTION = 0.72 / 0.8;
+var ADVISORY_RESET_BAND = 0.05;
+var INITIAL_ADVISORY_MEMORY = Object.freeze({
+  announcedPhase: "normal",
+  advisoryKey: null,
+  noCutKey: null
+});
+var ADVISORY_RANK = { normal: 0, notice: 1, prepare: 2 };
+function isPositiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isNonNegativeFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function resolvePressurePolicy(input = {}) {
+  const reduce = input.reduceThreshold ?? DEFAULT_REDUCE_THRESHOLD;
+  const target = input.workingSetTarget ?? DEFAULT_WORKING_SET_TARGET;
+  if (!Number.isFinite(reduce) || reduce <= 0 || reduce > 1) {
+    return { ok: false, reason: "reduce-threshold-out-of-range" };
+  }
+  if (!Number.isFinite(target) || target <= 0 || target >= reduce) {
+    return { ok: false, reason: "target-out-of-range" };
+  }
+  const hasNotice = input.noticeThreshold !== void 0;
+  const hasPrepare = input.prepareThreshold !== void 0;
+  if (hasNotice !== hasPrepare) return { ok: false, reason: "advisory-thresholds-incomplete" };
+  const notice = hasNotice ? input.noticeThreshold : reduce * NOTICE_PROPORTION;
+  const prepare = hasPrepare ? input.prepareThreshold : reduce * PREPARE_PROPORTION;
+  if (!Number.isFinite(notice) || !Number.isFinite(prepare)) {
+    return { ok: false, reason: "advisory-thresholds-out-of-order" };
+  }
+  if (!(notice > 0 && notice < prepare && prepare < reduce)) {
+    return { ok: false, reason: "advisory-thresholds-out-of-order" };
+  }
+  return {
+    ok: true,
+    policy: Object.freeze({ notice, prepare, reduce, target, derived: !hasNotice })
+  };
+}
+function advisoryIdentity(facts, policy) {
+  const identity = facts.contextIdentity ?? {};
+  return JSON.stringify([
+    "advisory/1",
+    facts.revision.sessionId,
+    facts.revision.branchAnchorTurnId,
+    Number.isFinite(facts.effectiveContextWindow) ? facts.effectiveContextWindow : null,
+    policy.notice,
+    policy.prepare,
+    policy.reduce,
+    policy.target,
+    identity.epoch ?? null,
+    identity.targetId ?? null,
+    identity.modelId ?? null,
+    identity.promptFingerprint ?? null,
+    identity.toolSignature ?? null
+  ]);
+}
+function requestIdentity(advisoryKey, facts) {
+  return JSON.stringify(["request/1", advisoryKey, facts.revision.revisionId]);
+}
+function unmeasuredDecision(facts, policy, prior, reason) {
+  return Object.freeze({
+    phase: "normal",
+    pressure: null,
+    headroomTokens: null,
+    measured: false,
+    inputSource: facts.inputSource,
+    completeInputTokens: null,
+    admission: Object.freeze({ result: "unknown", reason, requiredTokens: null }),
+    advisory: Object.freeze({
+      emit: false,
+      phase: "normal",
+      suppressedBy: "measurement-unknown"
+    }),
+    // An unmeasured turn carries prior memory through untouched. Advancing
+    // the advisory key here would consume the re-arm owed to a target, model,
+    // window, or policy change first seen without a usable reading.
+    memory: Object.freeze({ ...prior }),
+    policy
+  });
+}
+function evaluatePressure(facts, policy, prior = INITIAL_ADVISORY_MEMORY) {
+  if (!isPositiveFinite(facts.effectiveContextWindow)) {
+    return unmeasuredDecision(facts, policy, prior, "window-unknown");
+  }
+  if (facts.inputTokens === null || !Number.isFinite(facts.inputTokens) || facts.inputTokens < 0) {
+    return unmeasuredDecision(facts, policy, prior, "input-unknown");
+  }
+  const overhead = isNonNegativeFinite(facts.pendingRequestOverheadTokens) ? facts.pendingRequestOverheadTokens : null;
+  const reserve = isNonNegativeFinite(facts.outputReserveTokens) ? facts.outputReserveTokens : null;
+  if (overhead === null || reserve === null) {
+    return unmeasuredDecision(facts, policy, prior, "input-unknown");
+  }
+  const window = facts.effectiveContextWindow;
+  const completeInput = facts.inputTokens + overhead;
+  const required = completeInput + reserve;
+  const pressure = completeInput / window;
+  const headroom = window - required;
+  const advisoryKey = advisoryIdentity(facts, policy);
+  const requestKey = requestIdentity(advisoryKey, facts);
+  const noCutNow = facts.reduction === "no-useful-cut";
+  const noCutCarried = prior.noCutKey !== null && prior.noCutKey === requestKey;
+  const suppressedByNoCut = noCutNow || noCutCarried;
+  let phase;
+  let admission;
+  if (required > window) {
+    phase = "recover";
+    admission = {
+      result: "unsafe",
+      reason: suppressedByNoCut ? "exceeds-window-no-material" : "exceeds-window",
+      requiredTokens: required
+    };
+  } else if (pressure >= policy.reduce) {
+    phase = "reduce";
+    admission = {
+      result: suppressedByNoCut ? "admit" : "reduce-first",
+      reason: suppressedByNoCut ? "fits" : "pressure-at-reduce-threshold",
+      requiredTokens: required
+    };
+  } else {
+    phase = pressure >= policy.prepare ? "prepare" : pressure >= policy.notice ? "notice" : "normal";
+    admission = { result: "admit", reason: "fits", requiredTokens: required };
+  }
+  const advisoryPhase = phase === "notice" || phase === "prepare" ? phase : "normal";
+  const rearmed = prior.advisoryKey !== null && prior.advisoryKey !== advisoryKey;
+  const resetLevel = policy.notice * (1 - ADVISORY_RESET_BAND);
+  const fellBelowReset = pressure < resetLevel;
+  const announcedBefore = rearmed || fellBelowReset ? "normal" : prior.announcedPhase;
+  const actionWouldBeRequested = advisoryPhase !== "normal" || phase === "reduce" || phase === "recover";
+  let emit = false;
+  let suppressedBy = null;
+  if (suppressedByNoCut && actionWouldBeRequested) {
+    suppressedBy = "no-useful-cut-unchanged-revision";
+  } else if (advisoryPhase === "normal") {
+    suppressedBy = "not-crossed";
+  } else if (ADVISORY_RANK[advisoryPhase] > ADVISORY_RANK[announcedBefore]) {
+    emit = true;
+  } else {
+    suppressedBy = "already-announced";
+  }
+  const nextAnnounced = emit ? advisoryPhase : announcedBefore;
+  const nextNoCutKey = noCutNow || noCutCarried ? requestKey : null;
+  return Object.freeze({
+    phase,
+    pressure,
+    headroomTokens: headroom,
+    measured: true,
+    inputSource: facts.inputSource,
+    completeInputTokens: completeInput,
+    admission: Object.freeze(admission),
+    advisory: Object.freeze({ emit, phase: advisoryPhase, suppressedBy }),
+    memory: Object.freeze({ announcedPhase: nextAnnounced, advisoryKey, noCutKey: nextNoCutKey }),
+    policy
+  });
+}
+
+// src/domains/context/budget/live-view.ts
+function resolveLiveBudgetPolicy(reduceThreshold, workingSetTarget) {
+  const configured = resolvePressurePolicy({
+    ...typeof reduceThreshold === "number" ? { reduceThreshold } : {},
+    ...typeof workingSetTarget === "number" ? { workingSetTarget } : {}
+  });
+  if (configured.ok) return { policy: configured.policy, rejection: null };
+  const fallback = resolvePressurePolicy({
+    reduceThreshold: DEFAULT_REDUCE_THRESHOLD,
+    workingSetTarget: DEFAULT_WORKING_SET_TARGET
+  });
+  if (!fallback.ok) throw new Error(`default pressure policy is unresolvable: ${fallback.reason}`);
+  return { policy: fallback.policy, rejection: configured.reason };
+}
+function materialFingerprint(input) {
+  return createHash3("sha256").update(
+    JSON.stringify([
+      "live-budget/1",
+      input.sessionId,
+      input.branchAnchorTurnId,
+      input.navigationEpoch,
+      input.targetId,
+      input.runtimeId,
+      input.modelId,
+      input.modelApi,
+      input.effectiveWindow,
+      input.windowSource,
+      input.estimatedInputTokens,
+      input.anchoredInputTokens,
+      input.inputTokens,
+      input.inputSource,
+      input.historical,
+      input.breakdown,
+      input.breakdownSource,
+      input.outputReserveTokens,
+      input.thresholdReserveTokens,
+      input.policy.notice,
+      input.policy.prepare,
+      input.policy.reduce,
+      input.policy.target,
+      input.policyRejection,
+      input.reduction,
+      input.reductionBasisKey,
+      input.promptFingerprint,
+      input.toolSignature,
+      input.lastReduction,
+      input.pendingHandoff,
+      input.lastOutcome
+    ])
+  ).digest("hex");
+}
+function pressureFacts(input) {
+  return {
+    revision: {
+      sessionId: input.sessionId ?? "",
+      branchAnchorTurnId: input.branchAnchorTurnId,
+      // The policy reuses a no-cut refusal only for this exact identity, so
+      // it has to be the post-accounting one: a recalibrated anchor or a
+      // different resolved output cap is a request the reducer never saw.
+      revisionId: input.reductionBasisKey
+    },
+    inputTokens: input.inputTokens,
+    inputSource: input.inputSource === "anchored-plus-estimated-tail" ? "trusted" : "estimated",
+    effectiveContextWindow: input.effectiveWindow,
+    outputReserveTokens: input.outputReserveTokens ?? Number.NaN,
+    // The live estimate already prices pending text, tool schemas, and every
+    // injected block, so there is nothing left for the caller to add once.
+    pendingRequestOverheadTokens: 0,
+    reduction: input.reduction,
+    contextIdentity: {
+      targetId: input.targetId,
+      modelId: input.modelId,
+      promptFingerprint: input.promptFingerprint,
+      toolSignature: input.toolSignature,
+      epoch: input.navigationEpoch
+    }
+  };
+}
+function frozenCopy(value) {
+  return value === null ? null : Object.freeze({ ...value });
+}
+function createLiveBudgetProducer() {
+  let view = null;
+  let fingerprint = null;
+  let sequence = 0;
+  let memory = INITIAL_ADVISORY_MEMORY;
+  let decision = null;
+  return {
+    publish(input) {
+      const next = materialFingerprint(input);
+      const transitioned = next !== fingerprint;
+      if (transitioned) {
+        fingerprint = next;
+        sequence += 1;
+      }
+      const revision = `lb-${sequence}-${next.slice(0, 16)}`;
+      if (transitioned || decision === null) {
+        decision = evaluatePressure(pressureFacts(input), input.policy, memory);
+        memory = decision.memory;
+      }
+      view = Object.freeze({
+        revision,
+        capturedSnapshotId: input.capturedSnapshotId,
+        sessionId: input.sessionId,
+        branchAnchorTurnId: input.branchAnchorTurnId,
+        activeLeafTurnId: input.activeLeafTurnId,
+        activeUserTurnId: input.activeUserTurnId,
+        targetId: input.targetId,
+        runtimeId: input.runtimeId,
+        modelId: input.modelId,
+        modelApi: input.modelApi,
+        effectiveWindow: input.effectiveWindow,
+        windowSource: input.windowSource,
+        estimatedInputTokens: input.estimatedInputTokens,
+        anchoredInputTokens: input.anchoredInputTokens,
+        inputTokens: input.inputTokens,
+        inputSource: input.inputSource,
+        historical: input.historical,
+        breakdown: frozenCopy(input.breakdown),
+        breakdownSource: input.breakdownSource,
+        outputReserveTokens: input.outputReserveTokens,
+        thresholdReserveTokens: input.thresholdReserveTokens,
+        headroomTokens: decision.headroomTokens,
+        pressure: decision.pressure,
+        phase: decision.phase,
+        admission: decision.admission,
+        advisory: decision.advisory,
+        policy: Object.freeze({ ...input.policy }),
+        policyRejection: input.policyRejection,
+        reduction: input.reduction,
+        // Copied and frozen at this boundary. An injected reader owns the
+        // object it returns and may reuse or mutate it; a published view is
+        // the thing a revision names, and it does not change underneath one.
+        lastReduction: frozenCopy(input.lastReduction),
+        pendingHandoff: frozenCopy(input.pendingHandoff),
+        lastOutcome: frozenCopy(input.lastOutcome)
+      });
+      return view;
+    },
+    current() {
+      return view;
+    },
+    reset() {
+      view = null;
+      fingerprint = null;
+      decision = null;
+      memory = INITIAL_ADVISORY_MEMORY;
+    }
+  };
+}
 
 // src/domains/session/compaction/mask-observations.ts
 init_esm_shims();
@@ -4663,6 +5755,16 @@ function maskStaleObservations(entries, excludeLastTurns) {
   };
 }
 
+// src/interactive/output-reserve.ts
+init_esm_shims();
+function resolveTurnOutputReserve(agentRuntime, inputTokens) {
+  return resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions?.maxTokens, {
+    api: agentRuntime.agent.state.model?.api ?? "",
+    contextWindow: agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow,
+    inputTokens
+  });
+}
+
 // src/interactive/turn-context.ts
 function evictionSkipMessage(visibleEntries, workingSet, policyId) {
   const turns = visibleEntries.filter(isTurnStart).length;
@@ -4673,6 +5775,9 @@ function evictionSkipMessage(visibleEntries, workingSet, policyId) {
     policyId
   });
 }
+function messageListDigest(messages) {
+  return createHash4("sha256").update(JSON.stringify(messages)).digest("hex");
+}
 function createTurnContext(deps) {
   const { state, middleware } = deps;
   const compactionTrigger = new AutoCompactionTrigger();
@@ -4689,8 +5794,16 @@ function createTurnContext(deps) {
   let resumedPromptHashRead = false;
   let resumedPromptHash = null;
   const sessionWorkingContextPaths = /* @__PURE__ */ new Set();
+  let memoryTurnSequence = 0;
+  let memoryAuthorityEpoch = 0;
+  let memoryTurn = null;
+  const memoryOrigin = (runtime) => JSON.stringify([process.cwd(), runtime.targetId, runtime.runtimeId, runtime.wireModelId]);
   let pendingPromptLogEntry = null;
   let emptyAutoCompactContextKey = null;
+  const budgetProducer = createLiveBudgetProducer();
+  let branchAnchorTurnId = null;
+  let navigationEpoch = 0;
+  let noUsefulCutBasisKey = null;
   const pendingColdReasons = /* @__PURE__ */ new Set();
   let runExpectedColdReasons = [];
   let nextAssistantColdReasons = [];
@@ -4808,7 +5921,7 @@ function createTurnContext(deps) {
     resumedPromptHash = records[records.length - 1]?.systemPromptHash ?? null;
     return resumedPromptHash;
   };
-  const resolveWindowWithoutRuntime = () => {
+  const resolveWindowWithoutRuntime = (allowLedgerRead = true) => {
     const settings = deps.getSettings();
     const targetId = settings.chat?.target?.trim();
     const wireModelId = settings.chat?.model?.trim();
@@ -4820,7 +5933,7 @@ function createTurnContext(deps) {
       use: "orchestrator",
       requireTools: false,
       requireOutputBudget: true,
-      knownLoadedContextWindow: rememberedLoadedContextWindow(targetId, wireModelId)
+      knownLoadedContextWindow: allowLedgerRead ? rememberedLoadedContextWindow(targetId, wireModelId) : currentContextSnapshot?.contextWindowSource === "loaded" && currentContextSnapshot.providerId === targetId && currentContextSnapshot.modelId === wireModelId ? currentContextSnapshot.effectiveContextWindow : null
     });
     return resolved.ok ? resolved.target.contextWindowDetails : null;
   };
@@ -4834,8 +5947,8 @@ function createTurnContext(deps) {
     "unknown"
   ]);
   const snapshotWindowSource = (snapshot) => CONTEXT_WINDOW_SOURCES.has(snapshot.contextWindowSource) ? snapshot.contextWindowSource : null;
-  const windowWithoutRuntime = () => {
-    const details = resolveWindowWithoutRuntime();
+  const windowWithoutRuntime = (allowLedgerRead = true) => {
+    const details = resolveWindowWithoutRuntime(allowLedgerRead);
     if (details) {
       return {
         contextWindow: details.effectiveContextWindow,
@@ -4861,7 +5974,7 @@ function createTurnContext(deps) {
     const anchor = reconciledAnchor;
     if (!anchor) return null;
     const messages = agentRuntime.agent.state.messages.filter((message) => message.role !== "system");
-    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])) {
+    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]) || messageListDigest(messages.slice(0, anchor.anchoredMessages.length)) !== anchor.contentDigest) {
       reconciledAnchor = null;
       return null;
     }
@@ -4873,13 +5986,14 @@ function createTurnContext(deps) {
     }
     return anchor.tokens + tail;
   };
+  let pendingUserImages = [];
   const liveContextEstimate = (agentRuntime, pendingUserText) => {
     const contextWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
     const estimateInput = {
       systemPrompt: agentRuntime.agent.state.systemPrompt,
       messages: agentRuntime.agent.state.messages.filter((message) => message.role !== "system"),
       tools: agentRuntime.agent.state.tools,
-      ...pendingUserText !== void 0 ? { pendingUserText } : {}
+      ...pendingUserText !== void 0 ? { pendingUserText, pendingUserImages } : {}
     };
     const breakdown = estimateAgentContextBreakdown(estimateInput);
     const historyTokens = reconciledHistoryTokens(agentRuntime);
@@ -4897,12 +6011,177 @@ function createTurnContext(deps) {
       breakdown
     };
   };
+  const sha256Json = (value) => createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+  const liveBudgetContentFingerprint = (agentRuntime, pendingUserText, promptFingerprint, toolSignature) => {
+    const settings = deps.getSettings();
+    const eligibility = {
+      compaction: settings.context.compaction ?? null,
+      workingSet: settings.context.workingSet ?? null,
+      maxOutputTokens: settings.chat?.maxOutputTokens ?? null
+    };
+    if (!agentRuntime) {
+      const snapshot = currentContextSnapshot;
+      return sha256Json([
+        "historical/1",
+        settings.chat?.target ?? null,
+        settings.chat?.model ?? null,
+        snapshot?.snapshotId ?? null,
+        snapshot ? snapshotInputTokens(snapshot) : null,
+        snapshot?.sources.total ?? null,
+        windowWithoutRuntime(false).contextWindow,
+        promptFingerprint,
+        toolSignature,
+        eligibility
+      ]);
+    }
+    const details = agentRuntime.runtimeResolution.contextWindowDetails;
+    return sha256Json([
+      "live/1",
+      agentRuntime.targetId,
+      agentRuntime.runtimeId,
+      agentRuntime.wireModelId,
+      agentRuntime.agent.state.model?.api ?? null,
+      details.effectiveContextWindow,
+      details.contextWindowSource,
+      promptFingerprint,
+      toolSignature,
+      // Same serialization the anchor validates its attested prefix with, so
+      // the two cannot disagree about whether the conversation changed.
+      messageListDigest(agentRuntime.agent.state.messages.filter((message) => message.role !== "system")),
+      pendingUserText ?? null,
+      pendingUserText === void 0 ? null : pendingUserImages,
+      eligibility
+    ]);
+  };
+  const capturedBreakdown = (snapshot, pendingTokens) => ({
+    systemPromptTokens: snapshot.categories.system,
+    messageTokens: snapshot.categories.messages + (snapshot.categories.toolResults ?? 0),
+    pendingUserTokens: pendingTokens,
+    toolSchemaTokens: snapshot.categories.tools
+  });
+  const optionalProjection = (read) => {
+    if (!read) return null;
+    try {
+      return read();
+    } catch {
+      return null;
+    }
+  };
+  const liveRuntimeAccounting = (agentRuntime, pendingUserText) => {
+    const estimate = liveContextEstimate(agentRuntime, pendingUserText);
+    const details = agentRuntime.runtimeResolution.contextWindowDetails;
+    return {
+      targetId: agentRuntime.targetId,
+      runtimeId: agentRuntime.runtimeId,
+      modelId: agentRuntime.wireModelId,
+      modelApi: agentRuntime.agent.state.model?.api ?? null,
+      effectiveWindow: details.effectiveContextWindow > 0 ? details.effectiveContextWindow : null,
+      windowSource: details.contextWindowSource,
+      estimatedInputTokens: estimate.estimatedTokens,
+      anchoredInputTokens: estimate.reconciledTokens,
+      inputTokens: estimate.tokens,
+      inputSource: estimate.reconciledTokens === null ? "estimated" : "anchored-plus-estimated-tail",
+      historical: false,
+      breakdown: { ...estimate.breakdown },
+      breakdownSource: "live",
+      outputReserveTokens: resolveTurnOutputReserve(agentRuntime, estimate.tokens)
+    };
+  };
+  const historicalAccounting = (snapshot, settings) => {
+    const sameRoute = !snapshot || snapshot.providerId === settings.chat?.target && snapshot.modelId === settings.chat?.model;
+    const window = snapshot && !sameRoute ? {
+      contextWindow: snapshot.effectiveContextWindow,
+      contextWindowSource: snapshotWindowSource(snapshot)
+    } : windowWithoutRuntime(false);
+    const pendingTokens = pendingUserInputTokens();
+    return {
+      targetId: snapshot?.providerId ?? settings.chat?.target ?? null,
+      runtimeId: snapshot?.runtimeId ?? null,
+      modelId: snapshot?.modelId ?? settings.chat?.model ?? null,
+      modelApi: null,
+      effectiveWindow: window.contextWindow > 0 ? window.contextWindow : null,
+      windowSource: window.contextWindowSource,
+      estimatedInputTokens: snapshot?.estimatedTokens ?? null,
+      anchoredInputTokens: snapshot?.reconciledTokens ?? null,
+      inputTokens: snapshot ? snapshotInputTokens(snapshot) + pendingTokens : null,
+      inputSource: snapshot ? "historical" : "unknown",
+      historical: true,
+      breakdown: snapshot ? capturedBreakdown(snapshot, pendingTokens) : null,
+      breakdownSource: snapshot ? "captured" : null,
+      // No resolved route means no honest output reservation, and an unpriced
+      // reserve is unknown rather than zero.
+      outputReserveTokens: null
+    };
+  };
+  const liveBudgetInput = (pendingUserText) => {
+    const settings = deps.getSettings();
+    const agentRuntime = state.runtime;
+    const snapshot = currentContextSnapshot;
+    const promptFingerprint = agentRuntime ? sha256Json(agentRuntime.agent.state.systemPrompt ?? null) : snapshot?.promptHash ?? null;
+    const toolSignature = agentRuntime ? toolSignatureFromState(agentRuntime.agent.state.tools) : snapshot?.toolSignature ?? null;
+    const contentFingerprint = liveBudgetContentFingerprint(
+      agentRuntime,
+      pendingUserText,
+      promptFingerprint,
+      toolSignature
+    );
+    const policyResolution = resolveLiveBudgetPolicy(
+      settings.context.compaction?.threshold,
+      settings.context.workingSet?.target
+    );
+    const accounting = agentRuntime ? liveRuntimeAccounting(agentRuntime, pendingUserText) : historicalAccounting(snapshot, settings);
+    const reductionBasisKey = sha256Json([
+      "reduction-basis/1",
+      contentFingerprint,
+      accounting.effectiveWindow,
+      accounting.estimatedInputTokens,
+      accounting.anchoredInputTokens,
+      accounting.inputTokens,
+      accounting.inputSource,
+      accounting.outputReserveTokens,
+      // The resolved cap can move without moving the reservation, because a
+      // route clamp may be the binding constraint. Both belong in the key.
+      agentRuntime?.runtimeResolution.capabilityDecisions?.maxTokens ?? null,
+      snapshot?.categories.reserve ?? null,
+      policyResolution.policy.reduce,
+      policyResolution.policy.target
+    ]);
+    return {
+      ...accounting,
+      sessionId: deps.session?.current()?.id ?? snapshot?.sessionId ?? null,
+      branchAnchorTurnId,
+      activeLeafTurnId: state.lastTurnId,
+      activeUserTurnId: state.activeUserTurnId,
+      capturedSnapshotId: snapshot?.snapshotId ?? null,
+      // Compaction headroom recorded by the capture. Carried under its own
+      // name so nothing can mistake it for the output reserve.
+      thresholdReserveTokens: snapshot?.categories.reserve ?? null,
+      policy: policyResolution.policy,
+      policyRejection: policyResolution.rejection,
+      // Reduction has not been asked about unless an automatic attempt for
+      // this exact basis already came back empty.
+      reduction: noUsefulCutBasisKey !== null && noUsefulCutBasisKey === reductionBasisKey ? "no-useful-cut" : "unknown",
+      reductionBasisKey,
+      promptFingerprint,
+      toolSignature,
+      navigationEpoch,
+      lastReduction: lastCompactionEvent ? { ...lastCompactionEvent } : null,
+      pendingHandoff: optionalProjection(deps.getPendingHandoff),
+      lastOutcome: optionalProjection(deps.getLastOutcome)
+    };
+  };
+  const refreshLiveBudget = (pendingUserText) => budgetProducer.publish(liveBudgetInput(pendingUserText));
   const carryReconciledAnchorThroughProjection = (agentRuntime, historyTokens, tokensRemoved) => {
     if (!reconciledAnchor || historyTokens === null) return;
+    const anchoredMessages = [...agentRuntime.agent.state.messages.filter((message) => message.role !== "system")];
     reconciledAnchor = {
       ...reconciledAnchor,
       tokens: Math.max(0, historyTokens - Math.max(0, tokensRemoved)),
-      anchoredMessages: [...agentRuntime.agent.state.messages.filter((message) => message.role !== "system")]
+      anchoredMessages,
+      // Re-anchoring on the projected list is the point of this carry, so its
+      // content identity is retaken here. Keeping the old digest would fail
+      // the next validation and discard the attestation this preserves.
+      contentDigest: messageListDigest(anchoredMessages)
     };
   };
   const refreshAgentMessagesFromSession = (agentRuntime) => {
@@ -4910,7 +6189,11 @@ function createTurnContext(deps) {
     replaceEngineMessages(
       agentRuntime.agent,
       buildModelReplayAgentMessagesFromTurns(refreshedEntries, {
-        ...state.lastTurnId ? { activeLeafTurnId: state.lastTurnId } : {}
+        ...state.lastTurnId ? { activeLeafTurnId: state.lastTurnId } : {},
+        // The post-compaction rebuild is where an accepted note has to
+        // survive: wiring continuity only into /fork would lose it on the
+        // very refresh the reduction triggers.
+        continuity: continuityContextFromSession(deps.session)
       })
     );
     state.replayedContextMessages = [];
@@ -4948,9 +6231,11 @@ 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, pendingSkillPolicy, signal) => {
+  const performAutoCompact = async (agentRuntime, force, instructions, triggerOverride, pendingUserText, pendingSkillPolicy, signal, handoff) => {
     if (!deps.readSessionEntries) return false;
-    const useRequestBudget = !force || triggerOverride === "overflow";
+    const originSession = deps.session?.current()?.id;
+    const originNavigation = navigationEpoch;
+    const useRequestBudget = !force || triggerOverride === "overflow" || handoff !== void 0;
     const activeAutoTurnId = useRequestBudget ? state.activeUserTurnId : null;
     const skillContextState = mainSkillContextState(
       filterEntriesToActivePath(deps.readSessionEntries(), state.lastTurnId ?? void 0),
@@ -4961,10 +6246,11 @@ function createTurnContext(deps) {
     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)
+    const requiredFit = triggerOverride === "overflow";
+    const pressureEstimate = force && !requiredFit ? null : liveContextEstimate(agentRuntime, pendingUserText);
+    if (pressureEstimate && !requiredFit && !shouldCompact(pressureEstimate.tokens, compactionThreshold, pressureEstimate.contextWindow).shouldCompact)
       return false;
-    const attemptKey = !force && activeAutoTurnId ? createHash2("sha256").update(
+    const attemptKey = !force && activeAutoTurnId ? createHash4("sha256").update(
       JSON.stringify({
         turn: activeAutoTurnId,
         leaf: state.lastTurnId,
@@ -4988,7 +6274,9 @@ function createTurnContext(deps) {
     let preSummaryStageActed = false;
     let evictionSkipNotice = null;
     const rememberEmptyAutomaticAttempt = () => {
-      if (!force && !preSummaryStageActed && attemptKey) emptyAutoCompactContextKey = attemptKey;
+      if (force || preSummaryStageActed || !attemptKey) return;
+      emptyAutoCompactContextKey = attemptKey;
+      noUsefulCutBasisKey = liveBudgetInput(pendingUserText).reductionBasisKey;
     };
     const trigger = triggerOverride ?? (force ? "force" : "auto");
     if (pressureEstimate) {
@@ -4996,7 +6284,7 @@ function createTurnContext(deps) {
       const verdict = shouldCompact(estimate.tokens, compactionThreshold, estimate.contextWindow);
       if (deps.session?.current()) {
         const beforeSnapshotId = currentContextSnapshot?.snapshotId ?? null;
-        if (process.env.CLIO_CODER_LEGACY_MASK === "1") {
+        if (process.env.CLIO_CODER_LEGACY_MASK === "1" && !handoff) {
           let masked;
           try {
             masked = maskStaleObservations(deps.readSessionEntries() ?? [], 6);
@@ -5049,8 +6337,10 @@ function createTurnContext(deps) {
             deps.emitNotice(
               `[context engine] mask_observations: ${masked.maskedObservations} observations masked${thinkingNote}; ~${estimate.tokens} tokens -> ~${tokensAfterMask} tokens`
             );
+            refreshLiveBudget(pendingUserText);
             const after = liveContextEstimate(agentRuntime, pendingUserText);
-            if (!shouldCompact(after.tokens, compactionThreshold, after.contextWindow).shouldCompact) return true;
+            if (requiredFit ? requestFits(after.tokens, resolveTurnOutputReserve(agentRuntime, after.tokens), after.contextWindow) : !shouldCompact(after.tokens, compactionThreshold, after.contextWindow).shouldCompact)
+              return true;
           }
         } else if (settings.context.workingSet.enabled) {
           let planned;
@@ -5070,8 +6360,14 @@ function createTurnContext(deps) {
               pressure: {
                 tokens: estimate.tokens,
                 contextWindow: estimate.contextWindow,
-                threshold: compactionThreshold,
-                target: settings.context.workingSet.target
+                threshold: requiredFit ? Math.min(
+                  compactionThreshold,
+                  Math.max(0, 1 - resolveTurnOutputReserve(agentRuntime, estimate.tokens) / estimate.contextWindow)
+                ) : compactionThreshold,
+                target: requiredFit ? Math.min(
+                  settings.context.workingSet.target,
+                  Math.max(0, 1 - resolveTurnOutputReserve(agentRuntime, estimate.tokens) / estimate.contextWindow)
+                ) : settings.context.workingSet.target
               },
               estimateTokens
             });
@@ -5087,7 +6383,7 @@ function createTurnContext(deps) {
             emitCompactionActivity("started", "compacting context (working-set eviction)");
             try {
               const historyTokens = reconciledHistoryTokens(agentRuntime);
-              deps.session.appendEntry({
+              const evictionEntry = deps.session.appendEntry({
                 ...buildEvictionFields(planned, {
                   trigger: "pressure",
                   pressureBefore: verdict.pressure,
@@ -5097,6 +6393,10 @@ function createTurnContext(deps) {
                 // cursor is the leaf the next message will extend.
                 parentTurnId: state.lastTurnId
               });
+              if (deps.session.flushAppends) {
+                deps.session.flushAppends();
+                if (!handoff) notifyMemoryCommit(evictionEntry.turnId, "summary", "evicted");
+              }
               noteColdReason("working_set_evict");
               refreshAgentMessagesFromSession(agentRuntime);
               carryReconciledAnchorThroughProjection(agentRuntime, historyTokens, planned.tokensBefore - planned.tokensAfter);
@@ -5130,8 +6430,10 @@ function createTurnContext(deps) {
               deps.emitNotice(
                 `[context engine] working set: ${planned.items.length} ${itemsWord} evicted by ${planned.policyId}; ~${planned.tokensBefore} -> ~${planned.tokensAfter} tokens, recall by ref with context(scope="recall")`
               );
+              refreshLiveBudget(pendingUserText);
               const after = liveContextEstimate(agentRuntime, pendingUserText);
-              if (!shouldCompact(after.tokens, compactionThreshold, after.contextWindow).shouldCompact) return true;
+              if (requiredFit ? requestFits(after.tokens, resolveTurnOutputReserve(agentRuntime, after.tokens), after.contextWindow) : !shouldCompact(after.tokens, compactionThreshold, after.contextWindow).shouldCompact)
+                return true;
             } catch (error) {
               emitCompactionActivity("failed", compactionFailureMessage(error));
               throw error;
@@ -5173,14 +6475,7 @@ function createTurnContext(deps) {
     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 output = resolveTurnOutputReserve(agentRuntime, estimate.tokens);
       const inputTarget = Math.min(estimate.contextWindow * compactionThreshold, estimate.contextWindow - output);
       const staticTokens = estimate.breakdown.systemPromptTokens + estimate.breakdown.toolSchemaTokens;
       const calibration = Math.max(
@@ -5203,6 +6498,7 @@ function createTurnContext(deps) {
         try {
           return await deps.autoCompact?.(instructions, trigger, {
             ...budget,
+            ...handoff,
             signal: summarySignal
           }) ?? null;
         } finally {
@@ -5228,6 +6524,14 @@ function createTurnContext(deps) {
     if (!summaryLifecycleStarted) startSummaryLifecycle();
     deps.bus?.emit(BusChannels.CompactionEnd, { trigger, at: Date.now() });
     recordCompactionUsage(agentRuntime, result);
+    if (deps.memoryCommitBridge && !handoff && deps.session?.flushAppends) {
+      deps.session.flushAppends();
+      await deps.session.checkpoint("context-summary");
+      if (originSession !== deps.session.current()?.id || originNavigation !== navigationEpoch || signal?.aborted)
+        throw new Error("Context ownership changed during checkpoint.");
+      const summary = [...deps.readSessionEntries()].reverse().find((entry) => entry.kind === "compactionSummary");
+      if (summary) notifyMemoryCommit(summary.turnId, "summary", "summarized");
+    }
     refreshAgentMessagesFromSession(agentRuntime);
     reconciledAnchor = null;
     const postCompactSnapshot = captureRuntimeContextSnapshot(
@@ -5265,6 +6569,67 @@ function createTurnContext(deps) {
         isSplitTurn: result.isSplitTurn
       })
     );
+    refreshLiveBudget(pendingUserText);
+    return true;
+  };
+  let reductionInFlight = null;
+  const runAutoCompact = (...args) => {
+    if (reductionInFlight) {
+      if (args[7]) return Promise.reject(new Error("Another context reduction is already in progress."));
+      return reductionInFlight;
+    }
+    const operation = performAutoCompact(...args);
+    reductionInFlight = operation;
+    void operation.finally(() => {
+      if (reductionInFlight === operation) reductionInFlight = null;
+    }).catch(() => {
+    });
+    return operation;
+  };
+  const bindMemoryScope = () => {
+    const sessionId = deps.session?.current()?.id;
+    if (!sessionId) return null;
+    const scope = { sessionId, branchAnchorTurnId };
+    deps.memoryCommitBridge?.bindCommitScope(scope);
+    return scope;
+  };
+  const notifyMemoryCommit = (commitId, kind, outcome) => {
+    const scope = bindMemoryScope();
+    if (scope) deps.memoryCommitBridge?.notifyContextCommitted({ ...scope, commitId, kind, outcome });
+  };
+  const installMemoryRestoration = (runtime, pendingText) => {
+    const bridge = deps.memoryCommitBridge;
+    if (!bridge || !bindMemoryScope()) return false;
+    const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0);
+    const latest = [...entries].reverse().find((entry) => entry.kind === "continuityCommit" || entry.kind === "compactionSummary");
+    const currentState = latest?.kind === "continuityCommit" ? { kind: "handoff", text: latest.continuity.accepted.note } : latest?.kind === "compactionSummary" ? { kind: "summary", text: latest.summary } : null;
+    const view = refreshLiveBudget(pendingText);
+    const available = Math.max(
+      0,
+      (view.effectiveWindow ?? 0) - (view.outputReserveTokens ?? 0) - (view.inputTokens ?? 0) - 64
+    );
+    const offer = bridge.prepareRestoration(currentState, available);
+    if (!offer) return false;
+    if (!offer.message) {
+      bridge.acknowledgeRestoration(offer);
+      return false;
+    }
+    const message = {
+      role: "user",
+      content: `<system-reminder>
+${offer.message}
+</system-reminder>`,
+      timestamp: Date.now()
+    };
+    const cost = estimateAgentMessageTokens(message);
+    if (!requestFits((view.inputTokens ?? Infinity) + cost, view.outputReserveTokens, view.effectiveWindow)) return false;
+    const prior = [...runtime.agent.state.messages];
+    replaceEngineMessages(runtime.agent, [...prior, message]);
+    if (!bridge.acknowledgeRestoration(offer)) {
+      replaceEngineMessages(runtime.agent, prior);
+      return false;
+    }
+    refreshLiveBudget(pendingText);
     return true;
   };
   const toolResultTail = (agentRuntime) => {
@@ -5281,28 +6646,73 @@ function createTurnContext(deps) {
     thinkingLevel: agentRuntime.agent.state.thinkingLevel
   });
   return {
+    notifyMemoryCommit,
+    installMemoryRestoration,
+    prepareMemoryTurn(runtime, input) {
+      bindMemoryScope();
+      pendingUserImages = [...input.images ?? []];
+      if (input.continuation && memoryTurn !== null) return;
+      const sessionId = deps.session?.current()?.id ?? null;
+      memoryTurnSequence += 1;
+      memoryTurn = {
+        id: String(memoryTurnSequence),
+        sessionId,
+        sessionAuthority: JSON.stringify([memoryAuthorityEpoch, sessionId ?? `pending:${memoryTurnSequence}`]),
+        origin: memoryOrigin(runtime),
+        taskText: input.taskText,
+        activePaths: Object.freeze([...sessionWorkingContextPaths])
+      };
+    },
+    commitMemoryTurn(runtime) {
+      pendingUserImages = [];
+      if (memoryTurn?.sessionId === null && memoryTurn.origin === memoryOrigin(runtime)) {
+        memoryTurn.sessionId = deps.session?.current()?.id ?? null;
+      }
+    },
     captureRuntimeContextSnapshot,
     persistContextSnapshot,
     liveContextEstimate,
+    refreshLiveBudget,
     rememberedLoadedContextWindow,
     refreshAgentMessagesFromSession,
     runAutoCompact,
+    navigationRevision: () => navigationEpoch,
     cancelCompaction: () => compactionController?.abort(),
+    liveBudget: () => budgetProducer.current() ?? refreshLiveBudget(),
+    inspectLiveBudget() {
+      const targetId = deps.getSettings().chat?.target;
+      const target = !state.runtime && targetId ? deps.providers.getTarget(targetId) : null;
+      const runtime = state.runtime?.runtimeResolution.runtime ?? (target ? deps.providers.getRuntime(target.runtime) : null);
+      if (runtime && (!isOrchestratorEligibleRuntime(runtime) || runtime.externalAgentLoop))
+        return {
+          status: "unsupported",
+          reason: "The external agent owns its context; native request accounting is unavailable."
+        };
+      if (!runtime)
+        return {
+          status: "unavailable",
+          reason: "No native runtime descriptor is resolved. Inspection does not initialize a runtime."
+        };
+      return { status: "available", capability: "native", view: refreshLiveBudget() };
+    },
     setCurrentSnapshot(snapshot) {
       currentContextSnapshot = snapshot;
+      refreshLiveBudget(snapshot.pendingUserInput);
     },
     flushReconciledSnapshot() {
-      if (!snapshotPersistPending || !currentContextSnapshot) return;
-      persistContextSnapshot(currentContextSnapshot);
+      if (snapshotPersistPending && currentContextSnapshot) persistContextSnapshot(currentContextSnapshot);
+      refreshLiveBudget();
     },
     reconcileUsage(usage) {
       const promptTokens = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
       const runtime = state.runtime;
       if (promptTokens > 0 && runtime) {
         const breakdown = estimateAgentContextBreakdown({ ...runtime.agent.state, messages: [] });
+        const anchoredMessages = [...runtime.agent.state.messages.filter((message) => message.role !== "system")];
         reconciledAnchor = {
           tokens: promptTokens + (usage.output || 0),
-          anchoredMessages: [...runtime.agent.state.messages.filter((message) => message.role !== "system")],
+          anchoredMessages,
+          contentDigest: messageListDigest(anchoredMessages),
           runtime,
           model: runtime.agent.state.model,
           modelKey: anchorModelKey(runtime),
@@ -5313,7 +6723,10 @@ function createTurnContext(deps) {
           toolSchemaTokens: breakdown.toolSchemaTokens
         };
       }
-      if (!currentContextSnapshot) return;
+      if (!currentContextSnapshot) {
+        refreshLiveBudget();
+        return;
+      }
       if (runtime) {
         const messages = runtime.agent.state.messages.filter((message) => message.role !== "system");
         const promptMessages = messages.at(-1)?.role === "assistant" ? messages.slice(0, -1) : messages;
@@ -5331,6 +6744,7 @@ function createTurnContext(deps) {
       }
       currentContextSnapshot = reconcileSnapshot(currentContextSnapshot, usage);
       snapshotPersistPending = true;
+      refreshLiveBudget();
     },
     promptSideTokens() {
       return currentContextSnapshot ? snapshotInputTokens(currentContextSnapshot) : 0;
@@ -5375,7 +6789,20 @@ function createTurnContext(deps) {
       };
       if (deps.getMemorySection) {
         try {
-          const memorySection = deps.getMemorySection();
+          if (memoryTurn !== null && memoryTurn.sessionId !== (sessionId || null)) {
+            memoryAuthorityEpoch += 1;
+            memoryTurn = null;
+          }
+          const memorySection = deps.getMemorySection({
+            turnId: memoryTurn?.id ?? null,
+            sessionAuthority: memoryTurn?.sessionAuthority ?? JSON.stringify([memoryAuthorityEpoch, sessionId]),
+            cwd,
+            targetId: agentRuntime.targetId,
+            runtimeId: agentRuntime.runtimeId,
+            modelId: agentRuntime.wireModelId,
+            taskText: memoryTurn?.taskText ?? "",
+            activePaths: memoryTurn?.activePaths ?? []
+          });
           if (memorySection.length > 0) sessionInputs.memorySection = memorySection;
         } catch (err) {
           deps.emitNotice(
@@ -5481,15 +6908,25 @@ function createTurnContext(deps) {
     async postToolContinuationGuard(agentRuntime, signal, contextChanged = false) {
       if (signal?.aborted || !contextChanged && !toolResultTail(agentRuntime)) return void 0;
       const reminder = contextChanged ? agentRuntime.agent.state.messages.at(-1) : void 0;
+      const beforeView = refreshLiveBudget();
       const before = liveContextEstimate(agentRuntime);
-      if (before.contextWindow <= 0 || before.tokens <= 0) return void 0;
+      if (before.contextWindow <= 0) throw new Error("Context window is unavailable; continuation refused.");
       const settings = deps.getSettings();
       const threshold = settings.context.compaction?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
       const verdict = shouldCompact(before.tokens, threshold, before.contextWindow);
       let compacted = false;
-      if (verdict.shouldCompact) {
+      const mustFit = !requestFits(beforeView.inputTokens, beforeView.outputReserveTokens, beforeView.effectiveWindow);
+      if (mustFit || verdict.shouldCompact) {
         try {
-          compacted = await runAutoCompact(agentRuntime, false, void 0, "auto", void 0, void 0, signal);
+          compacted = await runAutoCompact(
+            agentRuntime,
+            mustFit,
+            void 0,
+            mustFit ? "overflow" : "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)}`
@@ -5499,28 +6936,23 @@ function createTurnContext(deps) {
       if (reminder && !agentRuntime.agent.state.messages.includes(reminder)) {
         agentRuntime.agent.state.messages.push(reminder);
       }
-      const after = liveContextEstimate(agentRuntime);
-      if (after.tokens >= after.contextWindow) {
+      const afterView = refreshLiveBudget();
+      if (!requestFits(afterView.inputTokens, afterView.outputReserveTokens, afterView.effectiveWindow)) {
         throw new Error(
-          `[Clio Coder] post-tool context guard stopped continuation before provider call: estimated ${after.tokens} tokens exceeds reported context window ${after.contextWindow}. Use /context compact, narrower reads, or a follow-up turn with smaller observations.`
+          `[Clio Coder] post-tool context guard stopped continuation before provider call: estimated input ${afterView.inputTokens} plus reserved output ${afterView.outputReserveTokens} tokens does not fit context window ${afterView.effectiveWindow}. Use /context compact, narrower reads, or a follow-up turn with smaller observations.`
         );
       }
       return compacted ? continuationContextUpdate(agentRuntime) : void 0;
     },
     contextUsage() {
-      const effectiveWindow = state.runtime ? state.runtime.runtimeResolution.contextWindowDetails.effectiveContextWindow : windowWithoutRuntime().contextWindow;
-      if (!currentContextSnapshot) {
-        return contextUsageSnapshot(null, effectiveWindow);
-      }
-      const pendingTokens = pendingUserInputTokens();
-      const totalUsed = snapshotInputTokens(currentContextSnapshot) + pendingTokens + liveStreamingOutputTokens();
-      const breakdown = {
-        systemPromptTokens: currentContextSnapshot.categories.system,
-        messageTokens: currentContextSnapshot.categories.messages + (currentContextSnapshot.categories.toolResults ?? 0),
-        pendingUserTokens: pendingTokens,
-        toolSchemaTokens: currentContextSnapshot.categories.tools
+      const view = budgetProducer.current() ?? refreshLiveBudget();
+      return {
+        ...contextUsageSnapshot(view.inputTokens, view.effectiveWindow, view.breakdown ?? void 0),
+        revision: view.revision,
+        inputSource: view.inputSource,
+        historical: view.historical,
+        breakdownSource: view.breakdownSource
       };
-      return contextUsageSnapshot(totalUsed > 0 ? totalUsed : null, effectiveWindow, breakdown);
     },
     contextLedger() {
       const settings = deps.getSettings();
@@ -5530,7 +6962,7 @@ function createTurnContext(deps) {
         contextWindow: state.runtime.runtimeResolution.contextWindowDetails.effectiveContextWindow,
         contextWindowSource: state.runtime.runtimeResolution.contextWindowDetails.contextWindowSource,
         contextWindowSlots: state.runtime.runtimeResolution.contextWindowDetails.contextWindowSlots
-      } : windowWithoutRuntime();
+      } : windowWithoutRuntime(false);
       const provider = state.runtime?.targetId ?? settings.chat?.target ?? null;
       const model = state.runtime?.wireModelId ?? settings.chat?.model ?? null;
       const liveToolCount = state.runtime?.agent.state.tools.length ?? 0;
@@ -5642,7 +7074,9 @@ function createTurnContext(deps) {
         };
       }
     },
-    resetForSession() {
+    resetForSession(incomingBranchAnchorTurnId = null) {
+      memoryTurn = null;
+      memoryAuthorityEpoch += 1;
       compactionController?.abort();
       if (sessionPromptHash !== null) noteColdReason("prompt_recompiled");
       lastPromptCache = null;
@@ -5655,7 +7089,12 @@ function createTurnContext(deps) {
       sessionWorkingContextPaths.clear();
       pendingPromptLogEntry = null;
       emptyAutoCompactContextKey = null;
+      noUsefulCutBasisKey = null;
       reconciledAnchor = null;
+      branchAnchorTurnId = incomingBranchAnchorTurnId;
+      navigationEpoch += 1;
+      bindMemoryScope();
+      budgetProducer.reset();
       const session = deps.session?.current();
       currentContextSnapshot = session ? getLatestContextSnapshot(session) : null;
     },
@@ -5671,9 +7110,17 @@ init_esm_shims();
 function createTurnMiddleware(deps) {
   const { state, middlewareToolChoice } = deps;
   const pendingReminders = [];
-  const bufferReminder = (message, severity, deferred = false) => {
+  const dropStale = () => {
+    for (let index = pendingReminders.length - 1; index >= 0; index--) {
+      if (pendingReminders[index]?.isCurrent?.() === false) pendingReminders.splice(index, 1);
+    }
+  };
+  const bufferReminder = (message, severity, deferred = false, isCurrent) => {
+    dropStale();
+    isCurrent ??= message.startsWith("Memory:") ? deps.memoryContentGuard?.() : void 0;
+    if (isCurrent?.() === false) return;
     if (pendingReminders.some((entry) => entry.message === message && entry.severity === severity)) return;
-    pendingReminders.push({ message, severity, deferred });
+    pendingReminders.push({ message, severity, deferred, isCurrent });
   };
   const runMiddlewareTurnHook = (input) => {
     if (!deps.middleware) return [];
@@ -5752,6 +7199,7 @@ function createTurnMiddleware(deps) {
         []
       );
       if (!current()) return false;
+      dropStale();
       const ready = pendingReminders.filter((entry) => entry.deferred);
       if (ready.length === 0) return false;
       const content = `<system-reminder>
@@ -5860,7 +7308,19 @@ ${[...new Set(ready.map((entry) => entry.message))].join("\n\n")}
         metadata
       });
     },
+    takePendingReminderProjection() {
+      const entries = pendingReminders.splice(0);
+      return () => {
+        const messages = [
+          ...new Set(entries.filter((entry) => entry.isCurrent?.() !== false).map((entry) => entry.message))
+        ];
+        return messages.length ? `<system-reminder>
+${messages.join("\n\n")}
+</system-reminder>` : "";
+      };
+    },
     flushPendingReminders() {
+      dropStale();
       if (pendingReminders.length === 0) return "";
       const messages = [...new Set(pendingReminders.map((entry) => entry.message))];
       pendingReminders.length = 0;
@@ -5871,12 +7331,14 @@ ${messages.join("\n\n")}
     clearPendingReminders() {
       pendingReminders.length = 0;
     },
-    injectDeferredReminder(message, severity = "advisory") {
+    injectDeferredReminder(message, severity = "advisory", isCurrent) {
+      dropStale();
+      if (isCurrent?.() === false) return;
       const text = message.trim();
       if (text.length === 0) return;
       const level = severity === "hard-block" ? "advisory" : severity;
       if (pendingReminders.some((entry) => entry.message === text)) return;
-      bufferReminder(text, level, true);
+      bufferReminder(text, level, true, isCurrent);
       appendMiddlewareReminderEntry(text, level);
       deps.emitNotice(text);
     },
@@ -5979,7 +7441,7 @@ function createTurnPersistence(deps) {
       costUsd: (total.costUsd ?? 0) + summary.costUsd
     };
   };
-  const appendAssistantTurn = (message, timing) => {
+  const appendAssistantTurn = (message, timing, deliveryId) => {
     if (message?.role !== "assistant") return;
     if (persistedAssistantMessages.has(message)) return;
     if (state.activeInterruptReason !== null && isEmptyAbortedAssistantMessage(message)) return;
@@ -5987,6 +7449,10 @@ function createTurnPersistence(deps) {
     const failure2 = terminalFailureFromAssistantMessage(message);
     const payload = assistantSessionPayload(message, failure2);
     if (timing) payload.timing = timing;
+    if (deliveryId) {
+      payload.continuityDeliveryId = deliveryId;
+      payload.stopReason = message.stopReason;
+    }
     const usage = message.usage;
     if (usage && typeof usage === "object") {
       const backendTimings = message.backendTimings;
@@ -6023,6 +7489,7 @@ function createTurnPersistence(deps) {
       tokens: traceUsage?.totalTokens ?? null
     });
     if (!turnContinues) finishTracedTurn(failure2 ? "fail" : "success", failure2?.errorMessage ?? null);
+    return turn.id;
   };
   return {
     wasPersisted(message) {
@@ -6196,7 +7663,7 @@ function createTurnPersistence(deps) {
 
 // src/interactive/turn-prewarm.ts
 init_esm_shims();
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // src/interactive/prewarm.ts
 init_esm_shims();
@@ -6322,7 +7789,7 @@ function createTurnPrewarm(deps) {
     if (Date.now() - started > 3e4) return { ran: false, reason: "expired" };
     if (deployment.endpoint && (endpointCapacityUsage()[deployment.endpoint] ?? 0) > 0)
       return { ran: false, reason: "dispatch-active" };
-    const prefix = createHash3("sha256").update(
+    const prefix = createHash5("sha256").update(
       JSON.stringify({
         model: runtime.agent.state.model,
         system: runtime.agent.state.systemPrompt,
@@ -7139,6 +8606,33 @@ function createTurnRuntime(deps) {
       },
       maxRetryDelayMs: deps.retrySettings().maxDelayMs,
       ...gatewaySessionId ? { sessionId: gatewaySessionId } : {},
+      beforeToolBatch: ({ assistantMessage }) => {
+        const calls = assistantMessage.content.filter((block) => block.type === "toolCall");
+        if (calls.some((call) => call.name === "self_compact") && calls.length !== 1) {
+          return { reason: "self_compact must be the only call in its batch; no sibling was executed." };
+        }
+        return void 0;
+      },
+      beforeStreamRequest: ({ context: request }) => {
+        setGlobalDefaultMaxOutputTokens(deps.getSettings().chat.maxOutputTokens);
+        if (state.activeInterruptReason !== null || state.runtime !== localRuntime) {
+          return { block: true, reason: "Request ownership changed before invocation." };
+        }
+        if (deps.hasQueuedSteering?.() && deps.continuity?.admission().block === false) {
+          const handoff = deps.continuity.admission();
+          if (!handoff.block && handoff.correlationId)
+            return { block: true, reason: "Operator steering arrived during handoff preparation; handoff paused." };
+        }
+        const view = context.refreshLiveBudget();
+        const resolved = resolvedRequestContext(request);
+        const actual = state.synthesisToolLock ? { ...resolved, systemPrompt: lockedSynthesisSystemPrompt(resolved.systemPrompt ?? "") } : request;
+        const input = Math.max(estimateInputTokensFromContext(actual), view.inputTokens ?? 0);
+        const output = resolveTurnOutputReserve(localRuntime, input);
+        return requestFits(input, output, view.effectiveWindow) ? deps.continuity?.admission() ?? { block: false } : {
+          block: true,
+          reason: `Context window exceeded: input ${input} + output ${output}, window ${view.effectiveWindow ?? "unknown"}.`
+        };
+      },
       onStreamInvocation: () => {
         setGlobalDefaultMaxOutputTokens(deps.getSettings().chat.maxOutputTokens);
         apiCallStartedAt = performance3.now();
@@ -7218,14 +8712,17 @@ function createTurnRuntime(deps) {
       );
       stallTimer.unref?.();
     };
-    handle.agent.prepareNextTurn = async (signal) => {
+    handle.agent.prepareNextTurnWithContext = async (_completed, signal) => {
       stallSuspendDepth += 1;
       try {
         if (signal?.aborted || state.activeInterruptReason !== null) return void 0;
-        const contextChanged = await middleware.prepareToolContinuation(localRuntime, signal);
+        if (deps.hasQueuedSteering?.()) await deps.continuity?.pause();
+        const handoffChanged = await deps.continuity?.settle(signal) ?? false;
+        const contextChanged = await middleware.prepareToolContinuation(localRuntime, signal) || handoffChanged;
         const update = await context.postToolContinuationGuard(localRuntime, signal, contextChanged);
+        const restored = context.installMemoryRestoration(localRuntime);
         if (signal?.aborted || state.activeInterruptReason !== null) return void 0;
-        return update ?? (contextChanged ? {
+        return (!restored ? update : void 0) ?? (contextChanged || restored ? {
           context: {
             messages: [...localRuntime.agent.state.messages],
             tools: [...localRuntime.agent.state.tools]
@@ -7434,7 +8931,9 @@ function createTurnRuntime(deps) {
           ttftMs: apiCallFirstDeltaAt !== null ? Math.round(Math.max(0, apiCallFirstDeltaAt - apiCallStartedAt)) : null,
           apiMs: Math.round(Math.max(0, eventClock - apiCallStartedAt))
         } : null;
-        persistence.appendAssistantTurn(enrichedEvent.message, timing);
+        const correlationId = event.type === "message_end" ? handle.requestCorrelationId(event.message) : void 0;
+        const persistedId = persistence.appendAssistantTurn(enrichedEvent.message, timing, correlationId);
+        await deps.continuity?.response(persistedId, correlationId);
         if (isAssistant) apiCallStartedAt = null;
         const usage = enrichedEvent.message.usage;
         if (isAssistant && usage && typeof usage === "object" && runFirstCallVerdict === null) {
@@ -7455,6 +8954,7 @@ function createTurnRuntime(deps) {
         pendingTerminalToolResult = enrichedEvent.result?.terminate === true ? { toolCallId: enrichedEvent.toolCallId, toolName: enrichedEvent.toolName } : null;
       }
       if (enrichedEvent.type === "agent_end") {
+        await deps.continuity?.pause();
         clearStallTimer();
         const terminal = pendingTerminalToolResult;
         pendingTerminalToolResult = null;
@@ -7633,6 +9133,7 @@ function createChatLoop(deps) {
     submit: (text, options) => submitTracked(text, options)
   });
   const middleware = createTurnMiddleware({
+    memoryContentGuard: deps.memoryCommitBridge?.isContentCurrent,
     state,
     middleware: deps.middleware,
     session: deps.session,
@@ -7641,7 +9142,9 @@ function createChatLoop(deps) {
     emitFooterNotice
   });
   try {
-    deps.registerDeferredReminderSink?.((message) => middleware.injectDeferredReminder(message));
+    deps.registerDeferredReminderSink?.(
+      (message, isCurrent) => middleware.injectDeferredReminder(message, "advisory", isCurrent)
+    );
     deps.registerDeferredNoticeSink?.((text) => middleware.emitDeferredNotice(text));
   } catch {
   }
@@ -7658,10 +9161,108 @@ function createChatLoop(deps) {
     readSessionEntries: deps.readSessionEntries,
     autoCompact: deps.autoCompact,
     getMemorySection: deps.getMemorySection,
+    memoryCommitBridge: deps.memoryCommitBridge,
     getReadySkillCount: deps.getReadySkillCount,
+    getPendingHandoff: () => {
+      const sessionId = deps.session?.current()?.id;
+      if (!sessionId) return null;
+      const fold = resolveContinuityProjection({
+        entries: filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0),
+        sessionId
+      }).current;
+      return fold?.identity && fold.phase !== "acknowledged" ? {
+        id: fold.identity.handoffId,
+        preparedAt: fold.policy ? new Date(fold.policy.preparedAtMs).toISOString() : null,
+        sourceRevision: fold.identity.sourceRevision
+      } : null;
+    },
+    getLastOutcome: () => {
+      const sessionId = deps.session?.current()?.id;
+      if (!sessionId) return null;
+      const fold = resolveContinuityProjection({
+        entries: filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0),
+        sessionId
+      }).current;
+      return fold?.identity ? { outcome: fold.phase, at: null, detail: fold.commit?.outcome ?? null } : null;
+    },
     middleware,
     emitNotice
   });
+  let continuityReplayInstalled = false;
+  const continuity = new ContinuityController({
+    captureOrigin: () => {
+      continuityReplayInstalled = false;
+      const session = deps.session;
+      const meta = session?.current();
+      const runtime = state.runtime;
+      const leaf = state.lastTurnId;
+      const operator = state.activeUserTurnId;
+      if (!session || !meta || !runtime || !leaf || !operator || context.inspectLiveBudget().status !== "available") {
+        throw new Error("Self-compaction requires a native runtime and a persisted operator turn.");
+      }
+      const revision = context.navigationRevision();
+      const route = `${deps.getSettings().chat.target}/${deps.getSettings().chat.model}`;
+      return {
+        sessionId: meta.id,
+        leafTurnId: leaf,
+        initiatingTurnId: operator,
+        sourceRevision: context.refreshLiveBudget().revision,
+        ports: createContinuityPersistencePorts({
+          session,
+          origin: {
+            sessionId: meta.id,
+            cwdHash: meta.cwdHash,
+            stillCurrent: () => context.navigationRevision() === revision && state.runtime === runtime && state.activeUserTurnId === operator && `${deps.getSettings().chat.target}/${deps.getSettings().chat.model}` === route
+          }
+        })
+      };
+    },
+    entries: () => filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0),
+    leaf: () => state.lastTurnId,
+    admitNote: (accepted) => {
+      const view = context.refreshLiveBudget();
+      if (!view.breakdown || view.historical) return false;
+      const messages = state.runtime?.agent.state.messages ?? [];
+      const operator = [...messages].reverse().find((message) => message.role === "user");
+      const note = continuityReplayText({
+        note: accepted.note,
+        handoffId: "pending",
+        commitId: "pending",
+        originSessionId: view.sessionId ?? "",
+        phase: "prepared",
+        authority: "execution"
+      });
+      const protectedSkills = messages.filter((message) => message.role === "toolResult" && message.toolName === "context").reduce((sum, message) => sum + estimateAgentMessageTokens(message), 0);
+      const floor = view.breakdown.systemPromptTokens + view.breakdown.toolSchemaTokens + protectedSkills + (operator ? estimateAgentMessageTokens(operator) : 0) + estimateAgentMessageTokens({ role: "assistant", content: [{ type: "text", text: note }] }) + 512;
+      return requestFits(floor, view.outputReserveTokens, view.effectiveWindow);
+    },
+    fits: () => {
+      const view = context.refreshLiveBudget();
+      return requestFits(view.inputTokens, view.outputReserveTokens, view.effectiveWindow);
+    },
+    inputTokens: () => context.refreshLiveBudget().inputTokens ?? 0,
+    reduce: async (hooks, signal) => {
+      if (!state.runtime) throw new Error("Native runtime was detached.");
+      continuityReplayInstalled = await context.runAutoCompact(
+        state.runtime,
+        true,
+        void 0,
+        "overflow",
+        void 0,
+        void 0,
+        signal,
+        hooks
+      );
+    },
+    installReplay: () => {
+      if (state.runtime && !continuityReplayInstalled) {
+        context.refreshAgentMessagesFromSession(state.runtime);
+        continuityReplayInstalled = true;
+      }
+    },
+    onCommit: (commitId, outcome) => context.notifyMemoryCommit(commitId, "continuity", outcome),
+    notice: emitNotice
+  });
   const persistence = createTurnPersistence({
     state,
     session: deps.session,
@@ -7697,6 +9298,8 @@ function createChatLoop(deps) {
     knownTargets: deps.knownTargets,
     observability: deps.observability,
     createAgent,
+    continuity,
+    hasQueuedSteering: () => queues.queuedMessages().steer.length > 0,
     middlewareToolChoice,
     persistence,
     context,
@@ -7919,6 +9522,11 @@ function createChatLoop(deps) {
       const images = options.images && options.images.length > 0 ? [...options.images] : void 0;
       const pendingSkillRequests = state.currentTurnConstraints?.skills === "disabled" ? [] : options.pendingSkillRequests ?? [];
       context.addWorkingContextPaths(options.workingContextPaths ?? []);
+      context.prepareMemoryTurn(agentRuntime, {
+        taskText: text,
+        continuation: options.requestContinuation === true,
+        images
+      });
       const pendingSkillPolicy = withModelSkillActivation(
         createPendingSkillToolPolicy(pendingSkillRequests) ?? state.activeSkillSurface,
         state.currentTurnConstraints?.skills !== "disabled" && modelMayActivateSkills(deps.getAutonomy?.() ?? deps.getSettings().safety.autonomy)
@@ -7933,7 +9541,7 @@ function createChatLoop(deps) {
       const toolSignature = toolSignatureFromState(agentRuntime.agent.state.tools);
       const askUserPolicy = createAskUserToolPolicy(agentRuntime.agent.state.tools);
       middleware.fireTurnStart(agentRuntime, text, pendingSkillRequests.length, options.requestContinuation === true);
-      const reminderBlock = middleware.flushPendingReminders();
+      const reminderProjection = middleware.takePendingReminderProjection();
       const skillPreamble = pendingSkillRequestPreamble(pendingSkillRequests);
       let taskMemoryHandoffSource = "";
       if (pendingSkillRequests.some((request) => request.name.trim() === "context-handoff")) {
@@ -7942,7 +9550,8 @@ function createChatLoop(deps) {
         } catch {
         }
       }
-      const submittedText = [reminderBlock, skillPreamble, taskMemoryHandoffSource, text].filter((part) => part.length > 0).join("\n\n");
+      const composeSubmittedText = () => [reminderProjection(), skillPreamble, taskMemoryHandoffSource, text].filter((part) => part.length > 0).join("\n\n");
+      let submittedText = composeSubmittedText();
       const forceNow = process.env.CLIO_CODER_FORCE_COMPACT === "1";
       try {
         setTurnPreparation("compacting");
@@ -7954,6 +9563,7 @@ function createChatLoop(deps) {
         endPreparationCompaction();
       }
       const compiledPrompt = await context.ensureSessionPrompt(agentRuntime);
+      submittedText = composeSubmittedText();
       const compactionThreshold = deps.getSettings().context.compaction?.threshold ?? null;
       const captureTurnSnapshot = (turnId) => context.captureRuntimeContextSnapshot(agentRuntime, turnId, compactionThreshold, {
         promptSegments: compiledPrompt ? compiledPrompt.sections.map((s) => ({ id: s.id, tokenEstimate: s.tokenEstimate })) : void 0,
@@ -7962,52 +9572,24 @@ function createChatLoop(deps) {
         promptHash: compiledPrompt?.systemPromptHash,
         toolSignature
       });
-      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 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...`
-        );
+      let admission = context.refreshLiveBudget(submittedText);
+      if (!requestFits(admission.inputTokens, admission.outputReserveTokens, admission.effectiveWindow)) {
         setTurnPreparation("compacting");
-        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;
+        let failure2;
+        await context.runAutoCompact(agentRuntime, true, void 0, "overflow", submittedText, pendingSkillPolicy).catch((error) => {
+          failure2 = error instanceof Error ? error.message : String(error);
         }).finally(endPreparationCompaction);
-        if (!compacted) {
+        submittedText = composeSubmittedText();
+        admission = context.refreshLiveBudget(submittedText);
+        if (!requestFits(admission.inputTokens, admission.outputReserveTokens, admission.effectiveWindow)) {
           emitAdmissionNotice(
-            `[Clio Coder] Request exceeds the context window and compaction could not reclaim enough space.${compactionFailure ? ` ${compactionFailure}.` : ""} Trim the prompt or reduce active tools.`,
+            `[Clio Coder] Request exceeds the available context window (input ${admission.inputTokens ?? "unknown"} + output ${admission.outputReserveTokens ?? "unknown"}, window ${admission.effectiveWindow ?? "unknown"}).${failure2 ? ` ${failure2}` : ""} Trim the prompt or reduce active tools.`,
             "context-window-exceeded"
           );
           return;
         }
-        context.refreshAgentMessagesFromSession(agentRuntime);
         turnSnapshot = captureTurnSnapshot("pending");
-        const postInputEstimate = budgetedPromptTokens(turnSnapshot);
-        const postTotalEstimate = postInputEstimate + outputForInput(postInputEstimate);
-        if (postTotalEstimate > effectiveWindow) {
-          emitAdmissionNotice(
-            `[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`,
-            "context-window-exceeded"
-          );
-          return;
-        }
-        emitNotice(
-          `[Clio Coder] Context budget check passed post-compaction (${postTotalEstimate} <= ${effectiveWindow}). Proceeding.`
-        );
       }
       const userTurnId = persistence.appendSubmittedUserTurn(
         agentRuntime,
@@ -8017,6 +9599,8 @@ function createChatLoop(deps) {
         text,
         options.display?.text
       );
+      context.installMemoryRestoration(agentRuntime, submittedText);
+      context.commitMemoryTurn(agentRuntime);
       if (interrupted)
         emit({
           type: "queued_user_turn",
@@ -8164,6 +9748,7 @@ function createChatLoop(deps) {
       }
     },
     cancel(options) {
+      continuity.cancel();
       const wasStreaming = state.streaming;
       context.cancelCompaction();
       recovery.cancelRetryCountdown();
@@ -8220,9 +9805,14 @@ function createChatLoop(deps) {
     contextUsage: () => context.contextUsage(),
     currentTurnConstraints: () => state.currentTurnConstraints,
     contextLedger: () => context.contextLedger(),
+    liveBudget: () => context.liveBudget(),
+    inspectLiveBudget: () => context.inspectLiveBudget(),
+    refreshLiveBudget: () => context.refreshLiveBudget(),
     whenSettled: () => activeSubmit,
     whenPrewarmSettled: () => prewarm.settled(),
     resetForSession(leafTurnId, replayMessages) {
+      continuity.cancel();
+      void continuity.pause();
       state.currentTurnConstraints = void 0;
       if (state.runtime) {
         state.runtime.agent.abort();
@@ -8235,7 +9825,7 @@ function createChatLoop(deps) {
       middlewareToolChoice.reset();
       state.lastTurnId = leafTurnId;
       state.lastRunSnapshot = null;
-      context.resetForSession();
+      context.resetForSession(leafTurnId);
       void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {
       });
       state.replayedContextMessages = replayMessages ? [...replayMessages] : [];
@@ -8327,6 +9917,26 @@ function createChatLoop(deps) {
       recordOutOfTurnUsage(prepared.runtime, result.usage, "handoff");
       return result.aborted ? { status: "aborted", text: result.text } : { status: "answered", text: result.text };
     },
+    requestSelfCompact: (note, toolCallId, signal) => continuity.request(note, toolCallId, signal),
+    async recoverHandoff(handoffId, action) {
+      if (state.streaming || state.turnPreparation !== "idle")
+        throw new Error("Wait for the current turn to settle before recovery.");
+      const runtime = turnRuntime.ensureRuntime();
+      if (!runtime) throw new Error("No native runtime is configured.");
+      state.activeInterruptReason = null;
+      if (!state.activeUserTurnId) {
+        const operator = [...filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? void 0)].reverse().find((entry) => entry.kind === "message" && entry.role === "user");
+        state.activeUserTurnId = operator?.turnId ?? null;
+      }
+      state.streaming = true;
+      try {
+        await continuity.recover(handoffId, action);
+        await continueEngineWithoutInput(runtime.agent);
+      } finally {
+        state.streaming = false;
+        await continuity.pause();
+      }
+    },
     async compact(instructions) {
       if (!deps.session?.current()) {
         emitNotice("[/context compact] no current session to compact; start one with /new or /resume first");
@@ -10001,7 +11611,7 @@ function createDispatchTool(inputDeps, surfaceOptions = {}) {
   const admission = createDispatchAdmissionController(deps);
   let runnerPromise = null;
   const loadRunner = () => {
-    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-NC7PYNIO.js")))();
+    runnerPromise ??= (surfaceOptions.loadRunner ?? (() => import("./dispatch-runner-VKVXVTWJ.js")))();
     return runnerPromise;
   };
   return {
@@ -10038,6 +11648,32 @@ function createDispatchTool(inputDeps, surfaceOptions = {}) {
   };
 }
 
+// src/tools/self-compact.ts
+init_esm_shims();
+function createSelfCompactTool(request) {
+  return {
+    name: ToolNames.SelfCompact,
+    description: "Save an exact handoff note and compact context before continuing this task. Call alone, with no sibling tools. Include current objective, decisions, evidence, paths, and next steps. A pending receipt is not proof of completion.",
+    parameters: typebox_exports.Object({
+      note_to_self: typebox_exports.String({
+        maxLength: 8192,
+        description: "Assistant-authored handoff text; nonblank, at most 8192 UTF-8 bytes. Preserved exactly."
+      })
+    }),
+    baseActionClass: "read",
+    executionMode: "sequential",
+    async run(args, options) {
+      try {
+        const note = args.note_to_self;
+        const output = await request(note, options?.toolCallId ?? "", options?.signal);
+        return { kind: "ok", output };
+      } catch (error) {
+        return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+      }
+    }
+  };
+}
+
 // src/tools/bootstrap.ts
 function registerAllTools(registry, deps = {}) {
   const cwd = deps.session?.current()?.cwd ?? process.cwd();
@@ -10047,6 +11683,10 @@ function registerAllTools(registry, deps = {}) {
     ...coreDeps,
     ...mcpCapabilities ? { mcpCapabilities } : {}
   });
+  if (deps.requestSelfCompact)
+    registry.register(
+      builtin(createSelfCompactTool(deps.requestSelfCompact), { path: "src/tools/self-compact.ts", scope: "core" })
+    );
   if (deps.dispatch) {
     const dispatch = deps.dispatch;
     const dispatchRunEvents = createDispatchRunEventRegistry({ journal: null });
@@ -10076,7 +11716,7 @@ function registerAllTools(registry, deps = {}) {
       ...builtin(
         lazyTool(
           monitorToolSurface,
-          async () => (await import("./monitor-LHNH577J.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
+          async () => (await import("./monitor-2HD3MC67.js")).createMonitorTool({ dispatch, runEvents: dispatchRunEvents })
         ),
         {
           path: "src/tools/monitor.ts",
@@ -10086,7 +11726,7 @@ function registerAllTools(registry, deps = {}) {
     });
     registry.register({
       ...builtin(
-        lazyTool(steerToolSurface, async () => (await import("./steer-KKYXJSH4.js")).createSteerTool({ dispatch })),
+        lazyTool(steerToolSurface, async () => (await import("./steer-D7RTAPCM.js")).createSteerTool({ dispatch })),
         {
           path: "src/tools/steer.ts",
           scope: "core"
@@ -10098,7 +11738,7 @@ function registerAllTools(registry, deps = {}) {
     const panes = deps.panes;
     registry.register({
       ...builtin(
-        lazyTool(panesToolSurface, async () => (await import("./panes-A743ONZ5.js")).createPanesTool({ panes })),
+        lazyTool(panesToolSurface, async () => (await import("./panes-TTPPSYCL.js")).createPanesTool({ panes })),
         { path: "src/tools/panes.ts", scope: "core" }
       )
     });
@@ -10598,6 +12238,15 @@ 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;
+  const continuity = resolveContinuityProjection({
+    entries,
+    sessionId: meta.id,
+    ...meta.parentSessionId && meta.parentTurnId ? { fork: { parentSessionId: meta.parentSessionId, parentTurnId: meta.parentTurnId } } : {}
+  });
+  const continuityNote = {
+    tokens: continuityProjectionTokens(continuity),
+    anchorTurnId: continuity.noteAnchorTurnId
+  };
   budget?.signal?.throwIfAborted();
   const systemPrompt = await readCompactionSystemPrompt(settings.context.compaction.systemPrompt, meta.cwd);
   budget?.signal?.throwIfAborted();
@@ -10625,6 +12274,7 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   try {
     result = await compact({
       entries,
+      continuityNote,
       ...budget,
       ...summarize ? { summarize } : {},
       onCall: (call) => calls.push(call),
@@ -10660,9 +12310,15 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
   if (result.usage) {
     result.usage = { ...result.usage, targetId: resolved.targetId, modelId: resolved.wireModelId };
   }
+  const settledContinuity = resolveContinuityProjection({
+    entries: filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId),
+    sessionId: meta.id,
+    ...meta.parentSessionId && meta.parentTurnId ? { fork: { parentSessionId: meta.parentSessionId, parentTurnId: meta.parentTurnId } } : {}
+  });
+  const continuityCarry = settledContinuity.current === null ? null : continuityPayloadFromFold(settledContinuity.current);
   const entry = {
     kind: "compactionSummary",
-    turnId: randomUUID2(),
+    turnId: randomUUID3(),
     parentTurnId: result.firstKeptTurnId ?? null,
     summary: result.summary,
     ...result.skillContext ? { skillContext: result.skillContext } : {},
@@ -10671,12 +12327,23 @@ async function runCompactionFlow(session, settings, providers, instructions, tri
     firstKeptTurnId: result.firstKeptTurnId ?? "",
     messagesSummarized: result.messagesSummarized,
     isSplitTurn: result.isSplitTurn,
-    tokensAfter: estimateTokensAfterCompaction(entries, result),
+    tokensAfter: estimateTokensAfterCompaction(entries, result, continuityNote.tokens),
+    // The latest validated fold, carried so the transaction survives the cut
+    // that is about to remove its earlier records from replay. It preserves
+    // the immutable identity, accepted note, original policy and commit; it
+    // never manufactures a commit and never turns an eviction-only outcome
+    // into a summarized one. A later ordinary compaction with no handoff of
+    // its own still carries the newest validated payload forward, which is
+    // what keeps an eviction-only commit's state alive across summary cycles.
+    ...continuityCarry === null ? {} : { continuity: continuityCarry },
     // The summarization call is a real model call. Persisting its provider
-    // usage on the entry is what puts it in front of `/cost` and `clio-coder usage
+    // usage on the entry is what puts it in front of `/usage` and `clio-coder usage
     // report`, which folded the ledger and so counted every call but this one.
     ...result.usage !== void 0 ? { usage: result.usage } : {}
   };
+  if (budget?.checkpointForSummary) {
+    entry.continuity = budget.checkpointForSummary(entry.turnId, entry.tokensBefore, entry.tokensAfter ?? 0);
+  }
   if (trigger !== void 0) entry.trigger = trigger;
   try {
     session.appendEntry(entry);
@@ -10724,11 +12391,11 @@ function estimateTokensFromSummary(result) {
     ...result.userContext ? { userContext: result.userContext } : {}
   });
 }
-function estimateTokensAfterCompaction(entries, result) {
+function estimateTokensAfterCompaction(entries, result, continuityNoteTokens = 0) {
   let droppedTokens = 0;
   for (const entry of entries.slice(0, result.firstKeptEntryIndex)) droppedTokens += estimateTokens(entry);
   const summaryTokens = estimateTokensFromSummary(result);
-  return Math.max(summaryTokens, result.tokensBefore - droppedTokens + summaryTokens);
+  return Math.max(summaryTokens + continuityNoteTokens, result.tokensBefore - droppedTokens + summaryTokens);
 }
 function advanceScopedTarget(settings, direction) {
   const scope = settings.chat.modelPicker.cycleSet ?? [];
@@ -11135,7 +12802,7 @@ async function bootOrchestrator(options = {}) {
     // A headless run submits no further turn, so a detached step could only
     // finish after the process that would have read it has exited.
     deliversDeferredReminders: options.headless === void 0,
-    onDeferredReminder: (message) => deferredMemoryReminderSink?.(message),
+    onDeferredReminder: (message, isCurrent) => deferredMemoryReminderSink?.(message, isCurrent),
     getSettings: () => {
       const memory = effectiveSettingsForDispatch?.().context.memory ?? memorySettings;
       return {
@@ -11315,6 +12982,8 @@ async function bootOrchestrator(options = {}) {
     getCwd: () => process.cwd()
   }) : null;
   const toolBootstrap = registerAllTools(toolRegistry, {
+    getContextBudget: () => chat.inspectLiveBudget(),
+    requestSelfCompact: (note, toolCallId, signal) => chat.requestSelfCompact(note, toolCallId, signal),
     getSettings: () => getCurrentSettings(),
     termination,
     captureWorkerContext: () => chat.captureWorkerContext?.() ?? null,
@@ -11589,21 +13258,7 @@ async function bootOrchestrator(options = {}) {
     bus,
     ...prompts ? { prompts } : {},
     ...session ? { session } : {},
-    getMemorySection: () => {
-      try {
-        const records = loadMemoryRecordsSync(clioDataDir());
-        const settings = getCurrentSettings();
-        const targetId = session?.current()?.target ?? settings.chat?.target;
-        const runtimeId = targetId ? providers.getTarget(targetId)?.runtime : void 0;
-        return buildMemoryPromptSection(records, {
-          scopes: ["global", "repo", "runtime"],
-          activeRepository: canonicalMemoryRepositoryIdentity(process.cwd()),
-          activeRuntime: runtimeId === void 0 ? null : { kind: "runtime", key: runtimeId }
-        }).section;
-      } catch {
-        return "";
-      }
-    },
+    getMemorySection: createMemoryPromptReader({ getDataDir: clioDataDir }),
     getTaskMemoryHandoffSource: () => {
       const meta = session?.current();
       if (!meta) throw new Error("task memory handoff requires an active session");
@@ -11617,6 +13272,7 @@ async function bootOrchestrator(options = {}) {
         agentIds: []
       });
     },
+    memoryCommitBridge: memoryIntervention,
     registerDeferredReminderSink: (sink) => {
       deferredMemoryReminderSink = sink;
     },
@@ -11659,10 +13315,14 @@ async function bootOrchestrator(options = {}) {
       try {
         chat.resetForSession(
           leafTurnId,
-          buildModelReplayAgentMessagesFromTurns(
-            readCurrentSessionEntries(),
-            leafTurnId ? { activeLeafTurnId: leafTurnId } : {}
-          )
+          buildModelReplayAgentMessagesFromTurns(readCurrentSessionEntries(), {
+            ...leafTurnId ? { activeLeafTurnId: leafTurnId } : {},
+            // The same ownership the interactive /resume overlay supplies.
+            // Without it this reader owns nothing, the fold finds no
+            // current origin, and a resumed session boots with its accepted
+            // note silently missing from the provider context.
+            continuity: continuityContextFromSession(session)
+          })
         );
       } catch (err) {
         chat.resetForSession(leafTurnId);
@@ -11700,7 +13360,14 @@ async function bootOrchestrator(options = {}) {
         ...session ? { session } : {},
         ...session ? {
           readSessionEntries: readSessionEntriesForCompact,
-          buildReplayMessages: (entries, leafTurnId) => buildModelReplayAgentMessagesFromTurns(entries, leafTurnId === null ? {} : { activeLeafTurnId: leafTurnId })
+          // Ownership is read at call time, not captured: an ACP client
+          // can switch sessions between turns, and a fork opened this way
+          // must separate its own transactions from the ones it inherited
+          // exactly as the interactive path does.
+          buildReplayMessages: (entries, leafTurnId) => buildModelReplayAgentMessagesFromTurns(entries, {
+            ...leafTurnId === null ? {} : { activeLeafTurnId: leafTurnId },
+            continuity: continuityContextFromSession(session)
+          })
         } : {},
         providers,
         // The fleet controls `clio-coder/dispatch/steer` reaches. The server
@@ -11737,7 +13404,7 @@ async function bootOrchestrator(options = {}) {
             providers,
             cwd: process.cwd(),
             runDoctor: async ({ deep }) => {
-              const { collectDoctorFindings, doctorNotice } = await import("./doctor-S5KZ2GTN.js");
+              const { collectDoctorFindings, doctorNotice } = await import("./doctor-53AVQXAO.js");
               return doctorNotice(
                 await collectDoctorFindings({
                   workspaceRoot: process.cwd(),
@@ -11886,7 +13553,7 @@ async function bootOrchestrator(options = {}) {
     dashboardPlugins = activePluginIds();
   });
   termination.onTerminate(() => unsubscribeDashboardPlugins());
-  const { startInteractive } = await import("./interactive-OXGYZYAS.js");
+  const { startInteractive } = await import("./interactive-JRCBENLZ.js");
   await startInteractive({
     getConnections: () => ({
       mcp: toolBootstrap.mcpCapabilities?.connectedIds({ readyOnly: true }) ?? [],
@@ -12089,6 +13756,7 @@ async function bootOrchestrator(options = {}) {
           );
         }
       },
+      onRecoverHandoff: (handoffId, action) => chat.recoverHandoff(handoffId, action),
       onCompact: async (instructions) => {
         await chat.compact(instructions);
       }
@@ -12114,4 +13782,4 @@ export {
   createBackgroundMemoryRouting,
   createProductionAutoCompact
 };
-//# sourceMappingURL=orchestrator-DTAPXULA.js.map
+//# sourceMappingURL=orchestrator-OUW3ZN6Y.js.map