@iowarp/clio-coder 0.5.0 → 0.5.2

package/src/interactive/turn-context.ts

@@ -1,4 +1,7 @@
+import type { SuccessfulMemoryContextCommit } from "../domains/memory/commit-state.js";
+import type { MemoryInterventionRegistration } from "../domains/middleware/memory-intervention.js";
 import { replaceEngineMessages, setEngineSystemPrompt } from "../engine/agent.js";
+import type { ContinuityReductionHooks } from "./continuity-controller.js";
 /**
  * Turn context ownership: the session-prompt compile cache, context-snapshot
  * accounting, prompt-cache honesty, and compaction. `runAutoCompact` is the
@@ -27,11 +30,23 @@ import type { SafeEventBus } from "../core/event-bus.js";
 import { residencyTargetKey } from "../core/residency-target-key.js";
 import type { PendingSkillToolPolicy } from "../core/skill-activation.js";
 import type { ToolName } from "../core/tool-names.js";
+import type { BudgetInspection } from "../domains/context/budget/inspection.js";
+import {
+	createLiveBudgetProducer,
+	type LiveBudgetBreakdown,
+	type LiveBudgetHandoffProjection,
+	type LiveBudgetInput,
+	type LiveBudgetOutcomeProjection,
+	type LiveBudgetView,
+	resolveLiveBudgetPolicy,
+} from "../domains/context/budget/live-view.js";
+import { requestFits } from "../domains/context/budget/request-fit.js";
 import { buildEvictionFields, planEviction } from "../domains/context/working-set/engine.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { isTurnStart } from "../domains/context/working-set/horizon.js";
 import { resolveWorkingSetPolicy } from "../domains/context/working-set/policies/index.js";
 import { selectVisibleEntries } from "../domains/context/working-set/visible.js";
+import type { MemoryPromptRequest } from "../domains/memory/prompt-cache.js";
 import type { ObservabilityContract } from "../domains/observability/contract.js";
 import type { CompiledSessionPrompt, SessionPromptInputs } from "../domains/prompts/compiler.js";
 import type { PromptsContract } from "../domains/prompts/contract.js";
@@ -39,6 +54,7 @@ import {
 	type ContextWindowDetails,
 	type ContextWindowSource,
 	canonicalEndpointKey,
+	isOrchestratorEligibleRuntime,
 	type ProvidersContract,
 	resolveRuntimeTarget,
 } from "../domains/providers/index.js";
@@ -56,7 +72,6 @@ import {
 	appendContextSnapshot,
 	type CaptureContextSnapshotInput,
 	type ContextSnapshot,
-	type ContextUsageBreakdown,
 	type ContextUsageSnapshot,
 	captureContextSnapshot,
 	ceilChars,
@@ -85,7 +100,6 @@ import {
 	type SessionPromptCompileRecord,
 } from "../domains/session/prompt-manifest.js";
 import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
-import { resolveReservedOutputTokens } from "../engine/apis/output-budget.js";
 import type { AgentMessage, Usage } from "../engine/types.js";
 import { resolveToolPromptHint, type ToolRegistry } from "../tools/registry.js";
 import {
@@ -94,14 +108,17 @@ import {
 	runtimeSupportsTools,
 	sumRunUsage,
 	toolNamesFromAgentState,
+	toolSignatureFromState,
 } from "./chat-loop-messages.js";
-import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
+import { buildModelReplayAgentMessagesFromTurns, continuityContextFromSession } from "./model-session-replay.js";
+import { resolveTurnOutputReserve } from "./output-reserve.js";
 import { attachedToolSchemasFromState, mainPromptCacheIdentity } from "./prompt-cache-identity.js";
 import { renderCompactionSummaryLine, renderEvictionSkipLine } from "./renderers/compaction-summary.js";
 import type { TurnMiddleware } from "./turn-middleware.js";
 import type { AgentRuntime, ChatTurnState } from "./turn-state.js";
 
 export interface TurnContextDeps {
+	memoryCommitBridge?: MemoryInterventionRegistration | undefined;
 	interactiveGuidance?: boolean;
 	state: ChatTurnState;
 	getSettings: () => Readonly<ClioSettings>;
@@ -116,13 +133,29 @@ export interface TurnContextDeps {
 		| ((
 				instructions?: string,
 				trigger?: CompactionTrigger,
-				budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+				budget?: Pick<
+					CompactInput,
+					| "keepRecentTokens"
+					| "preserveUserTurnId"
+					| "skillContextState"
+					| "signal"
+					| "beforeSummaryCall"
+					| "checkpointForSummary"
+				>,
 		  ) => Promise<CompactResult | null>)
 		| undefined;
 	/** Test seam for the eviction planner; production uses `planEviction` from the working-set engine. */
 	planEviction?: typeof planEviction;
-	getMemorySection?: (() => string) | undefined;
+	getMemorySection?: ((request: MemoryPromptRequest) => string) | undefined;
 	getReadySkillCount?: (() => number) | undefined;
+	/**
+	 * Optional continuity projections carried into the live budget view. They
+	 * are injected interfaces: this module never reads, writes, or validates the
+	 * durable records behind them, and a throwing reader degrades to null rather
+	 * than failing a budget publication.
+	 */
+	getPendingHandoff?: (() => LiveBudgetHandoffProjection | null) | undefined;
+	getLastOutcome?: (() => LiveBudgetOutcomeProjection | null) | undefined;
 	middleware: TurnMiddleware;
 	emitNotice: (text: string) => void;
 }
@@ -165,7 +198,23 @@ export type ExpectedColdReason =
 	 */
 	| "background_memory";
 
+export type LiveContextUsage = ContextUsageSnapshot &
+	Pick<LiveBudgetView, "revision" | "inputSource" | "historical" | "breakdownSource">;
+
 export interface TurnContext {
+	notifyMemoryCommit(
+		commitId: string,
+		kind: SuccessfulMemoryContextCommit["kind"],
+		outcome: SuccessfulMemoryContextCommit["outcome"],
+	): void;
+	installMemoryRestoration(runtime: AgentRuntime, pendingUserText?: string): boolean;
+	/** Prepare an attempt before preflight; rejected attempts never freeze the next submit. */
+	prepareMemoryTurn(
+		runtime: AgentRuntime,
+		input: { taskText: string; continuation: boolean; images?: ReadonlyArray<unknown> | undefined },
+	): void;
+	/** Bind first-session creation after append without rereading the prepared snapshot. */
+	commitMemoryTurn(runtime: AgentRuntime): void;
 	ensureSessionPrompt(agentRuntime: AgentRuntime): Promise<CompiledSessionPrompt | null>;
 	logPromptCompileIfPending(): void;
 	invalidateSessionPromptCache(): void;
@@ -188,6 +237,26 @@ export interface TurnContext {
 	 */
 	promptSideTokens(): number;
 	liveContextEstimate(agentRuntime: AgentRuntime, pendingUserText?: string): LiveContextEstimate;
+	/**
+	 * Recompute and publish the live budget view.
+	 *
+	 * Called at the seams that change the next request (capture, reconcile,
+	 * reduction, the mid-run tool-batch boundary, run settlement) and by any
+	 * consumer about to make a decision from it. The only thing it mutates is
+	 * the accounting cache: no
+	 * persistence, no model call, and no reduction happens because something
+	 * asked what the budget is.
+	 */
+	refreshLiveBudget(pendingUserText?: string): LiveBudgetView;
+	/**
+	 * The published live budget view. A pure getter for renderers and tools:
+	 * it never rescans the conversation or reprices the footer. The first call
+	 * of a session publishes once, because a view has to exist before it can be
+	 * read.
+	 */
+	liveBudget(): LiveBudgetView;
+	/** Inspect only when the native engine owns the request; never initialize it. */
+	inspectLiveBudget(): BudgetInspection;
 	/**
 	 * The loaded context window this session already recorded for a target and
 	 * model, so a resume budgets against it instead of re-probing. Null when the
@@ -203,6 +272,7 @@ export interface TurnContext {
 		pendingUserText?: string,
 		pendingSkillPolicy?: PendingSkillToolPolicy,
 		signal?: AbortSignal,
+		handoff?: ContinuityReductionHooks,
 	): Promise<boolean>;
 	cancelCompaction(): void;
 	postToolContinuationGuard(
@@ -218,7 +288,7 @@ export interface TurnContext {
 		  }
 		| undefined
 	>;
-	contextUsage(): ContextUsageSnapshot;
+	contextUsage(): LiveContextUsage;
 	contextLedger(): ContextLedger;
 	emitContextWindowWarningTransition(warning: string | null): void;
 	/** Record one known cache disturbance for the current or next call. */
@@ -235,7 +305,14 @@ export interface TurnContext {
 	 * of a disturbance, it is the prefix the next turn wants already resident.
 	 */
 	notePrewarm(prewarm: PrewarmStats): void;
-	resetForSession(): void;
+	/**
+	 * Drop per-session accounting. `branchAnchorTurnId` is the leaf the incoming
+	 * session's next turn parents under; it becomes the advisory branch identity,
+	 * which is why it is supplied only here. Ordinary appends advance the leaf
+	 * without re-arming an advisory; real navigation re-arms it.
+	 */
+	resetForSession(branchAnchorTurnId?: string | null): void;
+	navigationRevision(): number;
 	dispose(): void;
 }
 
@@ -260,6 +337,43 @@ function evictionSkipMessage(
 	});
 }
 
+/**
+ * The token and route facts of one budget publication, separate from the
+ * identity fields that name it. Split out so the live and pre-runtime paths
+ * produce the same shape and the reduction basis can be keyed over it after it
+ * is resolved rather than before.
+ */
+type LiveBudgetAccounting = Pick<
+	LiveBudgetInput,
+	| "targetId"
+	| "runtimeId"
+	| "modelId"
+	| "modelApi"
+	| "effectiveWindow"
+	| "windowSource"
+	| "estimatedInputTokens"
+	| "anchoredInputTokens"
+	| "inputTokens"
+	| "inputSource"
+	| "historical"
+	| "breakdown"
+	| "breakdownSource"
+	| "outputReserveTokens"
+>;
+
+/**
+ * Content identity of a message list.
+ *
+ * The one serialization used for both jobs that need to know whether the same
+ * message objects still hold the same bytes: validating a provider anchor's
+ * attested prefix, and fingerprinting the live request. Token counts cannot do
+ * either, because `estimateAgentMessageTokens` prices by character count and a
+ * same-length replacement leaves every figure identical.
+ */
+function messageListDigest(messages: ReadonlyArray<AgentMessage>): string {
+	return createHash("sha256").update(JSON.stringify(messages)).digest("hex");
+}
+
 export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	const { state, middleware } = deps;
 	const compactionTrigger = new AutoCompactionTrigger<CompactResult | null>();
@@ -282,6 +396,15 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	let reconciledAnchor: {
 		tokens: number;
 		anchoredMessages: ReadonlyArray<AgentMessage>;
+		/**
+		 * Content identity of `anchoredMessages` when the attestation was taken.
+		 * Object identity alone cannot detect an in-place edit: rewriting a
+		 * message's text with a different string of the same length leaves the
+		 * reference, the length, and therefore every chars/4 figure unchanged,
+		 * while the provider counted different tokens. Without this the anchor
+		 * would keep lending its authority to a prefix the provider never saw.
+		 */
+		contentDigest: string;
 		runtime: AgentRuntime;
 		model: AgentRuntime["agent"]["state"]["model"];
 		modelKey: string;
@@ -322,12 +445,38 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	let resumedPromptHashRead = false;
 	let resumedPromptHash: string | null = null;
 	const sessionWorkingContextPaths = new Set<string>();
+	let memoryTurnSequence = 0;
+	let memoryAuthorityEpoch = 0;
+	let memoryTurn: {
+		id: string;
+		sessionId: string | null;
+		sessionAuthority: string;
+		origin: string;
+		taskText: string;
+		activePaths: readonly string[];
+	} | null = null;
+	const memoryOrigin = (runtime: AgentRuntime): string =>
+		JSON.stringify([process.cwd(), runtime.targetId, runtime.runtimeId, runtime.wireModelId]);
 	let pendingPromptLogEntry: SessionPromptCompileRecord | null = null;
 	// Reuse an empty automatic attempt only for identical ledger and provider
 	// context. Same-turn tool growth or same-length content replacement must
 	// get a fresh cut; ordinary below-threshold checks never fingerprint it.
 	let emptyAutoCompactContextKey: string | null = null;
 
+	// The live budget view and the identity that decides when an advisory
+	// re-arms. `branchAnchorTurnId` moves only on real branch navigation, so two
+	// tool batches advancing `state.lastTurnId` under the same branch keep one
+	// advisory epoch; `navigationEpoch` separates two visits to the same leaf id.
+	const budgetProducer = createLiveBudgetProducer();
+	let branchAnchorTurnId: string | null = null;
+	let navigationEpoch = 0;
+	// Reduction-basis key of the last automatic attempt that produced nothing.
+	// It is the post-accounting identity, so a recalibrated anchor or a
+	// different resolved output cap clears the refusal even when the
+	// conversation, the route, and the configuration are byte-identical. The
+	// pressure policy reuses a refusal only for this exact key.
+	let noUsefulCutBasisKey: string | null = null;
+
 	// Cache-disturbance honesty (T3.3). Accumulate every known local-runtime
 	// disturbance and prefix-byte change since the last settled run. The next
 	// submit consumes the set, stamps `promptCache.expectedColdReasons` on its
@@ -517,7 +666,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		return resumedPromptHash;
 	};
 
-	const resolveWindowWithoutRuntime = (): ContextWindowDetails | null => {
+	const resolveWindowWithoutRuntime = (allowLedgerRead = true): ContextWindowDetails | null => {
 		const settings = deps.getSettings();
 		const targetId = settings.chat?.target?.trim();
 		const wireModelId = settings.chat?.model?.trim();
@@ -529,7 +678,13 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			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;
 	};
@@ -555,12 +710,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	 * resumed snapshot's recorded window, which is what the previous process
 	 * measured the same messages against.
 	 */
-	const windowWithoutRuntime = (): {
+	const windowWithoutRuntime = (
+		allowLedgerRead = true,
+	): {
 		contextWindow: number;
 		contextWindowSource: ContextWindowSource | null;
 		contextWindowSlots: ContextWindowDetails["contextWindowSlots"];
 	} => {
-		const details = resolveWindowWithoutRuntime();
+		const details = resolveWindowWithoutRuntime(allowLedgerRead);
 		if (details) {
 			return {
 				contextWindow: details.effectiveContextWindow,
@@ -589,6 +746,12 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		const anchor = reconciledAnchor;
 		if (!anchor) return null;
 		const messages = agentRuntime.agent.state.messages.filter((message) => message.role !== "system");
+		// The identity, route, and length checks are cheap and run first; `||`
+		// short-circuits, so the content digest is only computed for a prefix that
+		// still looks like the attested one. The digest covers the attested prefix
+		// and never the tail, so an append does not invalidate the anchor; the
+		// prefix itself is re-serialized and rehashed on every validation, which
+		// is the cost of detecting an in-place edit at all.
 		if (
 			anchor.runtime !== agentRuntime ||
 			anchor.model !== agentRuntime.agent.state.model ||
@@ -597,7 +760,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			anchor.runtimeId !== agentRuntime.runtimeId ||
 			anchor.wireModelId !== agentRuntime.wireModelId ||
 			anchor.anchoredMessages.length > messages.length ||
-			anchor.anchoredMessages.some((message, index) => message !== messages[index])
+			anchor.anchoredMessages.some((message, index) => message !== messages[index]) ||
+			messageListDigest(messages.slice(0, anchor.anchoredMessages.length)) !== anchor.contentDigest
 		) {
 			reconciledAnchor = null;
 			return null;
@@ -611,13 +775,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		return anchor.tokens + tail;
 	};
 
+	let pendingUserImages: ReadonlyArray<unknown> = [];
 	const liveContextEstimate = (agentRuntime: AgentRuntime, pendingUserText?: string): LiveContextEstimate => {
 		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 !== undefined ? { pendingUserText } : {}),
+			...(pendingUserText !== undefined ? { pendingUserText, pendingUserImages } : {}),
 		};
 		const breakdown = estimateAgentContextBreakdown(estimateInput);
 		const historyTokens = reconciledHistoryTokens(agentRuntime);
@@ -648,6 +813,240 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		};
 	};
 
+	const sha256Json = (value: unknown): string => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+	/**
+	 * Identity of the exact material the next request would carry, plus the
+	 * settings that decide its reserve and whether a reduction is even eligible.
+	 * This is the pre-accounting half: the reduction basis adds the resolved
+	 * estimate, cap, and reservation on top of it.
+	 *
+	 * Token counts alone cannot do this job: `estimateAgentMessageTokens` prices
+	 * by character count, so replacing a message with another of the same length
+	 * leaves every figure identical while the request is a different one. The
+	 * conversation is therefore hashed by content, not by length or count.
+	 */
+	const liveBudgetContentFingerprint = (
+		agentRuntime: AgentRuntime | null,
+		pendingUserText: string | undefined,
+		promptFingerprint: string | null,
+		toolSignature: string | null,
+	): string => {
+		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 === undefined ? null : pendingUserImages,
+			eligibility,
+		]);
+	};
+
+	/**
+	 * A captured decomposition, labelled as one. The mapping is the same the
+	 * `/context` overlay already uses, so the two cannot disagree; it is not a
+	 * fresh measurement of the live agent state and is never presented as one.
+	 */
+	const capturedBreakdown = (snapshot: ContextSnapshot, pendingTokens: number): LiveBudgetBreakdown => ({
+		systemPromptTokens: snapshot.categories.system,
+		messageTokens: snapshot.categories.messages + (snapshot.categories.toolResults ?? 0),
+		pendingUserTokens: pendingTokens,
+		toolSchemaTokens: snapshot.categories.tools,
+	});
+
+	const optionalProjection = <T>(read: (() => T | null) | undefined): T | null => {
+		if (!read) return null;
+		try {
+			return read();
+		} catch {
+			// A continuity projection is supplemental. Losing it must not stop the
+			// budget from being published.
+			return null;
+		}
+	};
+
+	/**
+	 * Token facts of the live next request, all from one `liveContextEstimate`
+	 * call: the same one admission budgets against. Old snapshot categories are
+	 * never summed to reconstruct the total, and streaming output is never added
+	 * on top, because the live next-request message list already carries the
+	 * completed assistant turn and the estimate already carries the pending
+	 * text. Each is charged exactly once.
+	 */
+	const liveRuntimeAccounting = (
+		agentRuntime: AgentRuntime,
+		pendingUserText: string | undefined,
+	): LiveBudgetAccounting => {
+		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),
+		};
+	};
+
+	/** Token facts before this process built a runtime: a persisted measurement, labelled as one. */
+	const historicalAccounting = (
+		snapshot: ContextSnapshot | null,
+		settings: Readonly<ClioSettings>,
+	): LiveBudgetAccounting => {
+		// Inspection uses already-loaded capture facts, never a diagnostic-ledger scan.
+		const sameRoute =
+			!snapshot || (snapshot.providerId === settings.chat?.target && snapshot.modelId === settings.chat?.model);
+		// A saved request from model A cannot acquire model B's window while
+		// retaining A's identity and input measurement. Keep that capture coherent.
+		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,
+		};
+	};
+
+	/**
+	 * Assemble one publication from the live runtime, or from the persisted
+	 * capture when this process has not built a runtime yet.
+	 */
+	const liveBudgetInput = (pendingUserText?: string): LiveBudgetInput => {
+		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,
+		);
+		// Two independent existing settings, not one derived from the other: the
+		// reduce point is `context.compaction.threshold` and the working-set
+		// target is `context.workingSet.target`. A pair the policy refuses is
+		// reported as a refusal rather than repaired into a fabricated setting.
+		const policyResolution = resolveLiveBudgetPolicy(
+			settings.context.compaction?.threshold,
+			settings.context.workingSet?.target,
+		);
+
+		// Accounting first, then the identity that describes it. A reduction
+		// refusal is only reusable for the request the reducer actually saw, and
+		// the resolved anchor, cap, and reservation are part of that request even
+		// when not a byte of the conversation moved.
+		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?: string): LiveBudgetView =>
+		budgetProducer.publish(liveBudgetInput(pendingUserText));
+
 	/**
 	 * A working-set projection removes tokens from messages the attestation
 	 * covered; it does not make the attestation wrong about the rest. Subtract
@@ -664,10 +1063,15 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		tokensRemoved: number,
 	): void => {
 		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),
 		};
 	};
 
@@ -677,6 +1081,10 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			agentRuntime.agent,
 			buildModelReplayAgentMessagesFromTurns(refreshedEntries, {
 				...(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 = [];
@@ -737,7 +1145,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	 * the LLM summary directly. Used for `/context compact`, CLIO_CODER_FORCE_COMPACT=1,
 	 * and overflow recovery.
 	 */
-	const runAutoCompact = async (
+	const performAutoCompact = async (
 		agentRuntime: AgentRuntime,
 		force: boolean,
 		instructions?: string,
@@ -745,11 +1153,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		pendingUserText?: string,
 		pendingSkillPolicy?: PendingSkillToolPolicy,
 		signal?: AbortSignal,
+		handoff?: ContinuityReductionHooks,
 	): Promise<boolean> => {
 		if (!deps.readSessionEntries) return false;
+		const originSession = deps.session?.current()?.id;
+		const originNavigation = navigationEpoch;
 		// Overflow forces a fit attempt even below the automatic threshold, but
 		// still needs the request budget and active task. Manual force keeps its defaults.
-		const useRequestBudget = !force || triggerOverride === "overflow";
+		const useRequestBudget = !force || triggerOverride === "overflow" || handoff !== undefined;
 		const activeAutoTurnId = useRequestBudget ? state.activeUserTurnId : null;
 		const skillContextState = mainSkillContextState(
 			filterEntriesToActivePath(deps.readSessionEntries(), state.lastTurnId ?? undefined),
@@ -760,9 +1171,11 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		const autoEnabled = cfg?.auto !== false;
 		if (!force && !autoEnabled) return false;
 		const compactionThreshold = cfg?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
-		const pressureEstimate = force ? null : liveContextEstimate(agentRuntime, pendingUserText);
+		const requiredFit = triggerOverride === "overflow";
+		const pressureEstimate = force && !requiredFit ? null : liveContextEstimate(agentRuntime, pendingUserText);
 		if (
 			pressureEstimate &&
+			!requiredFit &&
 			!shouldCompact(pressureEstimate.tokens, compactionThreshold, pressureEstimate.contextWindow).shouldCompact
 		)
 			return false;
@@ -802,7 +1215,12 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		// actually follows.
 		let evictionSkipNotice: string | null = null;
 		const rememberEmptyAutomaticAttempt = (): void => {
-			if (!force && !preSummaryStageActed && attemptKey) emptyAutoCompactContextKey = attemptKey;
+			if (force || preSummaryStageActed || !attemptKey) return;
+			emptyAutoCompactContextKey = attemptKey;
+			// The reducer was actually asked and found nothing. Record the request
+			// it was asked about, so the pressure policy can suppress a repeat
+			// advisory for that exact request and no other.
+			noUsefulCutBasisKey = liveBudgetInput(pendingUserText).reductionBasisKey;
 		};
 
 		const trigger: CompactionTrigger = triggerOverride ?? (force ? "force" : "auto");
@@ -816,7 +1234,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			// reachable only when explicitly requested.
 			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: ReturnType<typeof maskStaleObservations>;
 					try {
 						masked = maskStaleObservations(deps.readSessionEntries() ?? [], 6);
@@ -876,8 +1294,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 							`[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: ReturnType<typeof planEviction>;
@@ -897,8 +1321,18 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 							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,
 						});
@@ -914,7 +1348,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 						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,
@@ -924,6 +1358,10 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 								// 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);
@@ -967,8 +1405,19 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 								`[context engine] working set: ${planned.items.length} ${itemsWord} evicted by ${planned.policyId}; ~${planned.tokensBefore} -> ~${planned.tokensAfter} tokens, recall by ref with context(scope="recall")`,
 							);
 
+							// Published only after the carried anchor and the post-eviction
+							// capture are both in place: `liveContextEstimate` clears an
+							// anchor whose message prefix no longer matches, so pricing the
+							// rebuilt list any earlier would discard the attestation the
+							// projection carry exists to preserve.
+							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;
@@ -1017,18 +1466,19 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			snapshotMetadata,
 		);
 		let budget:
-			| Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">
+			| Pick<
+					CompactInput,
+					| "keepRecentTokens"
+					| "preserveUserTurnId"
+					| "skillContextState"
+					| "signal"
+					| "beforeSummaryCall"
+					| "checkpointForSummary"
+			  >
 			| undefined = skillContextState !== undefined ? { skillContextState } : undefined;
 		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(
@@ -1055,6 +1505,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 					return (
 						(await deps.autoCompact?.(instructions, trigger, {
 							...budget,
+							...handoff,
 							signal: summarySignal,
 						})) ?? null
 					);
@@ -1083,9 +1534,17 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 
 		// The checkpoint identifies the selected summary route; older results
 		// fall back to the active chat route. The ledger carries usage for reseed; this is the
-		// live sink, so `/cost` and the footer move the moment /context compact
+		// live sink, so `/usage` and the footer move the moment /context compact
 		// returns instead of staying byte-identical to before it ran.
 		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);
 		// A summary replaces the conversation the attestation described, so no
@@ -1129,6 +1588,75 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 				isSplitTurn: result.isSplitTurn,
 			}),
 		);
+		refreshLiveBudget(pendingUserText);
+		return true;
+	};
+
+	let reductionInFlight: Promise<boolean> | null = null;
+	const runAutoCompact: TurnContext["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: TurnContext["notifyMemoryCommit"] = (commitId, kind, outcome) => {
+		const scope = bindMemoryScope();
+		if (scope) deps.memoryCommitBridge?.notifyContextCommitted({ ...scope, commitId, kind, outcome });
+	};
+	const installMemoryRestoration: TurnContext["installMemoryRestoration"] = (runtime, pendingText) => {
+		const bridge = deps.memoryCommitBridge;
+		if (!bridge || !bindMemoryScope()) return false;
+		const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? undefined);
+		const latest = [...entries]
+			.reverse()
+			.find((entry) => entry.kind === "continuityCommit" || entry.kind === "compactionSummary");
+		const currentState =
+			latest?.kind === "continuityCommit"
+				? { kind: "handoff" as const, text: latest.continuity.accepted.note }
+				: latest?.kind === "compactionSummary"
+					? { kind: "summary" as const, 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: AgentMessage = {
+			role: "user",
+			content: `<system-reminder>\n${offer.message}\n</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;
 	};
 
@@ -1148,21 +1676,74 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	});
 
 	return {
+		notifyMemoryCommit,
+		installMemoryRestoration,
+		prepareMemoryTurn(runtime, input): void {
+			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): void {
+			pendingUserImages = [];
+			// appendSubmittedUserTurn creates the first session synchronously.
+			// Only that null -> bound transition with unchanged origin can alias
+			// its prepared authority; navigation never uses this exception.
+			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: (): LiveBudgetView => budgetProducer.current() ?? refreshLiveBudget(),
+		inspectLiveBudget(): BudgetInspection {
+			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: ContextSnapshot): void {
 			currentContextSnapshot = snapshot;
+			refreshLiveBudget(snapshot.pendingUserInput);
 		},
 
 		flushReconciledSnapshot(): void {
-			if (!snapshotPersistPending || !currentContextSnapshot) return;
-			persistContextSnapshot(currentContextSnapshot);
+			if (snapshotPersistPending && currentContextSnapshot) persistContextSnapshot(currentContextSnapshot);
+			// Run settlement. Its callers are `agent_end` and submit's finally, so
+			// this is where the finished run's accounting is published, not the
+			// mid-run tool-batch boundary; that one is `postToolContinuationGuard`.
+			refreshLiveBudget();
 		},
 
 		reconcileUsage(usage: Usage): void {
@@ -1172,11 +1753,13 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			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")];
 				// The output of this call is part of the next call's prompt for the
 				// same messages, which is why it is folded in here.
 				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),
@@ -1187,7 +1770,12 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 					toolSchemaTokens: breakdown.toolSchemaTokens,
 				};
 			}
-			if (!currentContextSnapshot) return;
+			if (!currentContextSnapshot) {
+				// The anchor still moved, and it is what the next request budgets
+				// against, so the view is republished with or without a snapshot.
+				refreshLiveBudget();
+				return;
+			}
 			// Reconcile in memory on every API call so the live meters
 			// track usage; persistence waits for the run to settle.
 			if (runtime) {
@@ -1208,6 +1796,9 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			}
 			currentContextSnapshot = reconcileSnapshot(currentContextSnapshot, usage);
 			snapshotPersistPending = true;
+			// A reconcile moves the anchor and therefore the figure the next
+			// request budgets against, so it is a publication point of its own.
+			refreshLiveBudget();
 		},
 
 		promptSideTokens(): number {
@@ -1271,7 +1862,20 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			};
 			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(
@@ -1387,16 +1991,29 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			// ledger turn. Preserve its newly appended context tail if compaction
 			// rebuilds messages from the ledger, and count it in both estimates.
 			const reminder = contextChanged ? agentRuntime.agent.state.messages.at(-1) : undefined;
+			// The tool batch appended results the last publication predates, and the
+			// guard is about to decide on them. Publish before that inspection, not
+			// after it.
+			const beforeView = refreshLiveBudget();
 			const before = liveContextEstimate(agentRuntime);
-			if (before.contextWindow <= 0 || before.tokens <= 0) return undefined;
+			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, undefined, "auto", undefined, undefined, signal);
+					compacted = await runAutoCompact(
+						agentRuntime,
+						mustFit,
+						undefined,
+						mustFit ? "overflow" : "auto",
+						undefined,
+						undefined,
+						signal,
+					);
 				} catch (err) {
 					throw new Error(
 						`[Clio Coder] post-tool context guard could not compact before continuation: ${err instanceof Error ? err.message : String(err)}`,
@@ -1407,32 +2024,28 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			if (reminder && !agentRuntime.agent.state.messages.includes(reminder)) {
 				agentRuntime.agent.state.messages.push(reminder);
 			}
-			const after = liveContextEstimate(agentRuntime);
-			if (after.tokens >= after.contextWindow) {
+			// The mid-run settled tool-batch boundary: whatever the guard did or
+			// declined to do, this is the context the continuation will send.
+			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) : undefined;
 		},
 
-		contextUsage(): ContextUsageSnapshot {
-			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: ContextUsageBreakdown = {
-				systemPromptTokens: currentContextSnapshot.categories.system,
-				messageTokens: currentContextSnapshot.categories.messages + (currentContextSnapshot.categories.toolResults ?? 0),
-				pendingUserTokens: pendingTokens,
-				toolSchemaTokens: currentContextSnapshot.categories.tools,
+		contextUsage(): LiveContextUsage {
+			// Footer reads project the last publication. They never rescan the
+			// ledger or add streaming output to the next-request message estimate.
+			const view = budgetProducer.current() ?? refreshLiveBudget();
+			return {
+				...contextUsageSnapshot(view.inputTokens, view.effectiveWindow, view.breakdown ?? undefined),
+				revision: view.revision,
+				inputSource: view.inputSource,
+				historical: view.historical,
+				breakdownSource: view.breakdownSource,
 			};
-			return contextUsageSnapshot(totalUsed > 0 ? totalUsed : null, effectiveWindow, breakdown);
 		},
 
 		contextLedger(): ContextLedger {
@@ -1449,7 +2062,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 						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;
@@ -1581,7 +2194,9 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			}
 		},
 
-		resetForSession(): void {
+		resetForSession(incomingBranchAnchorTurnId: string | null = null): void {
+			memoryTurn = null;
+			memoryAuthorityEpoch += 1;
 			compactionController?.abort();
 			// An in-process switch replaces the whole prefix: the backend's slot
 			// still holds the outgoing session's prompt and history, so the first
@@ -1602,7 +2217,15 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			sessionWorkingContextPaths.clear();
 			pendingPromptLogEntry = null;
 			emptyAutoCompactContextKey = null;
+			noUsefulCutBasisKey = null;
 			reconciledAnchor = null;
+			// Real branch navigation. The epoch separates two visits to the same
+			// leaf id, so an advisory announced on the branch this session left is
+			// re-armed rather than treated as already said.
+			branchAnchorTurnId = incomingBranchAnchorTurnId;
+			navigationEpoch += 1;
+			bindMemoryScope();
+			budgetProducer.reset();
 			const session = deps.session?.current();
 			currentContextSnapshot = session ? getLatestContextSnapshot(session) : null;
 		},