@iowarp/clio-coder 0.5.1 → 0.5.2

package/src/interactive/footer/widgets.ts

@@ -1,5 +1,6 @@
 import type { OutputStyle } from "../../core/defaults.js";
 import { ToolNames } from "../../core/tool-names.js";
+import type { LiveBudgetView } from "../../domains/context/budget/live-view.js";
 import {
 	type CostAggregate,
 	formatCostAggregate,
@@ -99,6 +100,8 @@ export interface SessionFacts {
 
 /** Context engine telemetry. */
 export interface ContextEngineFacts {
+	/** Identifies the published accounting used by the meter; ledger stays diagnostic. */
+	budget?: Pick<LiveBudgetView, "revision" | "historical" | "inputSource">;
 	label: string | null;
 	used: number | null;
 	contextWindow: number | null;
@@ -393,14 +396,36 @@ function contextComposition(context: ContextEngineFacts): {
 		system: finiteNonNegative(breakdown?.systemPromptTokens),
 		tools: finiteNonNegative(breakdown?.toolSchemaTokens),
 		chat: finiteNonNegative(breakdown?.messageTokens) + finiteNonNegative(breakdown?.pendingUserTokens),
-		free: window > 0 ? Math.max(0, window - used) : null,
+		free:
+			window > 0 && typeof context.used === "number" && Number.isFinite(context.used) ? Math.max(0, window - used) : null,
 	};
 }
 
+/** Short truthful occupancy label shared by compact and expanded surfaces. */
+export function contextUsageText(context: ContextEngineFacts): string {
+	const used = context.budget ? context.used : (context.ledger?.usedTokens ?? context.used);
+	const window = context.budget ? context.contextWindow : (context.ledger?.contextWindow ?? context.contextWindow);
+	const source = context.budget?.inputSource === "historical" ? "saved " : context.budget && used !== null ? "~" : "";
+	return `${source}${used === null ? "?" : formatFooterTokens(used)} / ${window ? formatFooterTokens(window) : "?"}`;
+}
+
+/** Reads published numbers only; never refreshes accounting from a renderer. */
+export function contextOccupancyBar(context: ContextEngineFacts, cells: number, theme: ClioTheme): string {
+	if (!context.budget && context.ledger) return renderContextMeterBar(context.ledger, cells, theme);
+	return buildSegmentedContextBar(
+		theme,
+		cells,
+		context.contextWindow ?? 0,
+		context.used === null ? undefined : contextBreakdownForBar(context),
+	);
+}
+
 /** The live window after the percent; null when unknown or the row is too narrow to carry it. */
 export function compactContextWindowLabel(context: ContextEngineFacts, width: number): string | null {
 	if (width < 72) return null;
-	const window = finiteNonNegative(context.ledger?.contextWindow ?? context.contextWindow);
+	const window = finiteNonNegative(
+		context.budget ? context.contextWindow : (context.ledger?.contextWindow ?? context.contextWindow),
+	);
 	return window > 0 ? formatFooterTokens(window) : null;
 }
 
@@ -427,7 +452,7 @@ export function compactSecondaryLine(
 	const safeWidth = Math.max(1, Math.floor(width));
 	const barCells = compactContextBarWidth(safeWidth);
 	let left = "";
-	if (context.ledger) {
+	if (context.ledger && !context.budget) {
 		// The row follows the kv grammar: dim key, muted value. An unmeasured
 		// percent renders the ?% placeholder dim because it is scaffolding for a
 		// number that has not arrived, not a measurement.
@@ -437,7 +462,7 @@ export function compactSecondaryLine(
 		);
 		left = `${theme.fg("dim", "ctx")} ${renderContextMeterBar(context.ledger, barCells, theme)} ${percent}`;
 	} else {
-		left = buildSegmentedContextBar(theme, barCells, context.contextWindow ?? 0, contextBreakdownForBar(context));
+		left = `${context.budget?.inputSource === "historical" ? theme.fg("dim", "saved ") : ""}${contextOccupancyBar(context, barCells, theme)}`;
 	}
 	// A percentage alone does not say whether the window is 128k or 1M, so at
 	// widths that can afford it the live window follows the percent. It comes
@@ -713,7 +738,7 @@ function ledgerBar(theme: ClioTheme, ledger: ContextLedger, cells: number): stri
 export function contextQuadrant(facts: ContextEngineFacts, options: ExpandedQuadrantOptions = {}): string[] {
 	const theme = clioTheme();
 	const ledger = facts.ledger ?? null;
-	const hasLedger = ledger !== null && ledger.contextWindow > 0;
+	const hasLedger = !facts.budget && ledger !== null && ledger.contextWindow > 0;
 	const barCells = expandedContextBarCells(options.width);
 
 	let bar: string;
@@ -737,7 +762,7 @@ export function contextQuadrant(facts: ContextEngineFacts, options: ExpandedQuad
 				? theme.style("frame", `free ${formatFooterTokens(composition.free)}`, { dim: true })
 				: null,
 		]);
-		bar = buildSegmentedContextBar(theme, barCells, facts.contextWindow ?? 0, contextBreakdownForBar(facts));
+		bar = contextOccupancyBar(facts, barCells, theme);
 		const filledChar = visibleWidth(GLYPH.contextFull) === 1 ? GLYPH.contextFull : GLYPH.barFull;
 		const freeChar = visibleWidth(GLYPH.contextFree) === 1 ? GLYPH.contextFree : GLYPH.barEmpty;
 		legendRows = [
@@ -752,7 +777,7 @@ export function contextQuadrant(facts: ContextEngineFacts, options: ExpandedQuad
 		"Context",
 		[
 			statusRow(bar),
-			kv("used", formatUsedWindow(usedTokens, windowTokens)),
+			kv("used", facts.budget ? contextUsageText(facts) : formatUsedWindow(usedTokens, windowTokens)),
 			fill ? styledKv("fill", fill) : statusRow(null),
 			chatFree ? styledKv("budget", chatFree) : statusRow(null),
 			kv("compact", formatCompaction(facts)),

package/src/interactive/interactive-application.ts

@@ -252,6 +252,7 @@ export interface InteractiveDeps {
 	 * engine, and persists a compactionSummary entry.
 	 */
 	onCompact?: (instructions: string | undefined) => Promise<void>;
+	onRecoverHandoff?: (handoffId: string, action: "reduce" | "deliver") => Promise<void>;
 	/** Run /context init for the current working directory. */
 	onInit?: (options: InitCommandOptions, io?: RunIo) => Promise<void>;
 	/** Run /context reset for the current working directory. */
@@ -827,6 +828,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		...(deps.onSelectModel ? { onSelectModel: deps.onSelectModel } : {}),
 		...(deps.onSetThinkingLevel ? { onSetThinkingLevel: deps.onSetThinkingLevel } : {}),
 		...(deps.onCompact ? { onCompact: deps.onCompact } : {}),
+		...(deps.onRecoverHandoff ? { onRecoverHandoff: deps.onRecoverHandoff } : {}),
 		...(deps.onInit ? { onInit: deps.onInit } : {}),
 		...(deps.onContextClear ? { onContextClear: deps.onContextClear } : {}),
 		...(deps.onContextRefresh ? { onContextRefresh: deps.onContextRefresh } : {}),

package/src/interactive/interactive-slash-runtime.ts

@@ -36,6 +36,7 @@ import { appendNotice, appendOperatorAside, appendOperatorCommand, appendReferen
 import { runOperatorRecall } from "./context-recall-command.js";
 import { renderSessionHtml } from "./export-html/index.js";
 import { dateLocal } from "./format-time.js";
+import { withContinuityReplay } from "./model-session-replay.js";
 import type { OracleDigestSources } from "./oracle.js";
 import type { PendingModelScope } from "./overlays/model-scope.js";
 import { renderDoctorReport } from "./renderers/doctor-report.js";
@@ -57,6 +58,15 @@ import type { WorkerEntryState } from "./worker-stream.js";
 
 const EXPORT_RENDER_WIDTH = 100;
 
+/** Longest run of consecutive backticks in the rendered transcript, for fence sizing. */
+function longestBacktickRun(lines: ReadonlyArray<string>): number {
+	let longest = 0;
+	for (const line of lines) {
+		for (const run of line.match(/`+/gu) ?? []) longest = Math.max(longest, run.length);
+	}
+	return longest;
+}
+
 export interface InteractiveSlashSubmitExpansion {
 	text: string;
 	images: ImageContent[];
@@ -104,6 +114,7 @@ export interface InteractiveSlashRuntimeDeps {
 	onSelectModel?: (ref: { target: string; model: string }, scope: "session" | "global") => void;
 	onSetThinkingLevel?: (level: ThinkingLevel, scope?: "session" | "global") => void;
 	onCompact?: (instructions: string | undefined) => Promise<void>;
+	onRecoverHandoff?: (handoffId: string, action: "reduce" | "deliver") => Promise<void>;
 	onInit?: (options: InitCommandOptions, io?: RunIo) => Promise<void>;
 	onContextClear?: (options: ContextClearCommandOptions, io?: RunIo) => Promise<void>;
 	onContextRefresh?: (io?: RunIo) => Promise<void>;
@@ -584,6 +595,17 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 			deps.setEditorText(text);
 			deps.requestRender();
 		},
+		runHandoffRecovery: (handoffId, action) => {
+			if (!deps.onRecoverHandoff) {
+				appendCommandNotice("error", "[/context recover] native handoff recovery is unavailable");
+				return;
+			}
+			void deps
+				.onRecoverHandoff(handoffId, action)
+				.catch((error) =>
+					appendCommandNotice("error", `[/context recover] ${error instanceof Error ? error.message : String(error)}`),
+				);
+		},
 		runCompact: (instructions) => {
 			runCompactWithNotice(deps.onCompact, appendCommandNotice, instructions);
 		},
@@ -608,10 +630,19 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 				// rehydrate exported it as ordinary history (issue #109). No session
 				// contract means no pin can exist for this reader, so the file replays whole.
 				const leafTurnId = deps.session?.tree(sessionId).leafId ?? null;
-				rehydrateChatPanelFromTurns(exportPanel, turns, {
-					unboundedToolBodies: true,
-					...(leafTurnId ? { activeLeafTurnId: leafTurnId } : {}),
-				});
+				// The export shows the same continuity the model sees, resolved from
+				// the same ledger through the same helper, so the two cannot drift.
+				// It is labelled as assistant handoff text and is never rendered as an
+				// operator turn.
+				rehydrateChatPanelFromTurns(
+					exportPanel,
+					turns,
+					withContinuityReplay(
+						turns,
+						{ unboundedToolBodies: true, ...(leafTurnId ? { activeLeafTurnId: leafTurnId } : {}) },
+						deps.session,
+					),
+				);
 				const ansiLines = exportPanel.render(EXPORT_RENDER_WIDTH);
 				// The operator names this file by the day they ran the export, so the
 				// date in it is their calendar date. The header below keeps the ISO
@@ -626,8 +657,14 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 				mkdirSync(resolve(target, ".."), { recursive: true });
 				if (markdown) {
 					const lines = ansiLines.map(stripTerminalSequences);
-					const header = [`# Clio session ${sessionId}`, "", `Exported ${exportedAt.toISOString()}`, "", "```text"];
-					writeFileSync(target, `${[...header, ...lines, "```", ""].join("\n")}`, "utf8");
+					// The fence has to be longer than the longest backtick run the
+					// transcript contains, or a body that includes its own fence closes
+					// the block early and the rest of the session renders as Markdown.
+					// A handoff note is assistant-authored prose that routinely carries
+					// fenced code, so this is reachable content, not a hypothetical.
+					const fence = "`".repeat(Math.max(3, longestBacktickRun(lines) + 1));
+					const header = [`# Clio session ${sessionId}`, "", `Exported ${exportedAt.toISOString()}`, "", `${fence}text`];
+					writeFileSync(target, `${[...header, ...lines, fence, ""].join("\n")}`, "utf8");
 				} else {
 					writeFileSync(target, renderSessionHtml({ sessionId, exportedAt: exportedAt.toISOString(), ansiLines }), "utf8");
 				}

package/src/interactive/model-session-replay.ts

@@ -1,8 +1,123 @@
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { projectWorkingSet } from "../domains/context/working-set/project.js";
+import {
+	type ContinuityForkBinding,
+	type ContinuityProjection,
+	continuityReplayBlocks,
+	resolveContinuityProjection,
+} from "../domains/session/continuity/projection.js";
+import type { SessionContract } from "../domains/session/contract.js";
 import type { SessionEntry } from "../domains/session/entries.js";
 import type { AgentMessage } from "../engine/types.js";
-import { buildReplayAgentMessagesFromTurns, type RehydrateChatPanelOptions } from "./chat-renderer.js";
+import {
+	activeEntriesBeforeCompactionCut,
+	buildReplayAgentMessagesFromTurns,
+	type RehydrateChatPanelOptions,
+} from "./chat-renderer.js";
+
+/**
+ * The session-ownership facts continuity needs, which a renderer does not have.
+ *
+ * Supplying this is what separates a fork's own transactions from the ones it
+ * inherited. Without it a reader owns nothing: inherited recall still projects,
+ * because losing the note is the one outcome that is never safe, but no
+ * transaction can reach execution authority.
+ */
+export interface ContinuityReplayContext {
+	/** The opened session's actual id, from `session.current()`. */
+	sessionId?: string;
+	/** `meta.parentSessionId` / `meta.parentTurnId`, when this session is a fork. */
+	fork?: ContinuityForkBinding;
+	/**
+	 * True only for a genuine historical cut of this session's own transactions.
+	 * A live `/tree` selection is not one, even though the renderer passes
+	 * `uptoTurnId` for both.
+	 */
+	historical?: boolean;
+	/** Parse failures the reader counted, so a torn record cannot become permission. */
+	unreadableRecords?: number;
+	nowMs?: number;
+}
+
+export interface ModelReplayOptions extends RehydrateChatPanelOptions {
+	continuity?: ContinuityReplayContext;
+}
+
+/**
+ * Derive replay ownership from the open session.
+ *
+ * `meta.parentSessionId` and `meta.parentTurnId` are what `enrichForkMeta`
+ * stamps on a child, and together they are the fork binding. The header's
+ * `parentSession` is a path to the parent's ledger, a different fact, and is
+ * deliberately not used as a session id. A session with no fork pointers
+ * publishes no binding, so a foreign-origin record in a session that never
+ * forked stays unprojected instead of being read as inheritance.
+ *
+ * `historical` is never set here. A replay is historical only when a caller
+ * standing at a past turn says so; deriving it from the renderer's `uptoTurnId`
+ * would make an ordinary `/tree` selection permanently surrender this session's
+ * ownership of its own transactions.
+ */
+export function continuityContextFromSession(
+	/** Narrowed to the one method this needs, so partial session owners qualify. */
+	session: Pick<SessionContract, "current"> | undefined,
+): ContinuityReplayContext {
+	const meta = session?.current();
+	if (!meta) return {};
+	const parentSessionId = meta.parentSessionId ?? null;
+	const parentTurnId = meta.parentTurnId ?? null;
+	return {
+		sessionId: meta.id,
+		...(parentSessionId !== null && parentTurnId !== null ? { fork: { parentSessionId, parentTurnId } } : {}),
+	};
+}
+
+/**
+ * Resolve the continuity projection for a replay.
+ *
+ * Folded over the active path **before** the compaction cut and before the
+ * working-set projection, because both of those remove records the fold needs:
+ * a commit, a pause or an operator control request older than the cut is still
+ * the evidence for the state the note describes. `withContinuityReplay` is the
+ * exported entry point, so the transcript and the model always render blocks
+ * from one resolution rather than two.
+ */
+function resolveReplayContinuity(
+	entries: ReadonlyArray<SessionEntry>,
+	options: ModelReplayOptions = {},
+): ContinuityProjection {
+	const context = options.continuity ?? {};
+	return resolveContinuityProjection({
+		// The positional cut applies only to a real historical selection. A live
+		// /tree switch passes `uptoTurnId` for display and must still see the
+		// sidecars anchored after the selected message, because they are part of
+		// its own branch's current state.
+		entries: activeEntriesBeforeCompactionCut(entries, options, context.historical === true),
+		...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),
+		...(context.fork === undefined ? {} : { fork: context.fork }),
+		...(context.historical === undefined ? {} : { historical: context.historical }),
+		...(context.unreadableRecords === undefined ? {} : { unreadableRecords: context.unreadableRecords }),
+		...(context.nowMs === undefined ? {} : { nowMs: context.nowMs }),
+	});
+}
+
+/**
+ * Resolve continuity once and hand the same finished blocks to both surfaces.
+ *
+ * The transcript and the model must show byte-identical note text, so the
+ * projection is resolved here and the rendered blocks travel on the options
+ * object that `rehydrateChatPanelFromTurns` and
+ * `buildModelReplayAgentMessagesFromTurns` both receive. Resolving it twice
+ * would be two chances to disagree.
+ */
+export function withContinuityReplay(
+	turns: ReadonlyArray<SessionEntry>,
+	options: RehydrateChatPanelOptions,
+	session: Pick<SessionContract, "current"> | undefined,
+): ModelReplayOptions {
+	const merged: ModelReplayOptions = { ...options, continuity: continuityContextFromSession(session) };
+	return { ...merged, continuityBlocks: continuityReplayBlocks(resolveReplayContinuity(turns, merged)) };
+}
 
 /**
  * Build provider-facing replay messages from the durable session ledger.
@@ -10,12 +125,24 @@ import { buildReplayAgentMessagesFromTurns, type RehydrateChatPanelOptions } fro
  * setting gates creation of new evictions, not replay of durable state.
  * Visible transcript and export callers intentionally keep using the raw
  * rehydration helpers so eviction remains a model projection, not data loss.
+ *
+ * Continuity is resolved first, from the complete pre-cut ledger, so the
+ * accepted note survives both the working-set projection and the compaction
+ * cut. It is carried as labelled data and never becomes a synthetic operator
+ * instruction.
  */
 export function buildModelReplayAgentMessagesFromTurns(
 	entries: ReadonlyArray<SessionEntry>,
-	options: RehydrateChatPanelOptions = {},
+	options: ModelReplayOptions = {},
 ): AgentMessage[] {
 	const activeLeafTurnId = options.activeLeafTurnId ?? options.uptoTurnId;
+	// A caller that already resolved the projection passes its blocks through,
+	// so the transcript beside this replay renders the identical bytes.
+	const blocks = options.continuityBlocks ?? continuityReplayBlocks(resolveReplayContinuity(entries, options));
 	const projected = projectWorkingSet(entries, foldWorkingSet(entries, activeLeafTurnId), activeLeafTurnId);
-	return buildReplayAgentMessagesFromTurns(projected, { ...options, skillContextEntries: entries });
+	return buildReplayAgentMessagesFromTurns(projected, {
+		...options,
+		skillContextEntries: entries,
+		continuityBlocks: blocks,
+	});
 }

package/src/interactive/output-reserve.ts

@@ -0,0 +1,35 @@
+/**
+ * The one preflight output reservation a turn asks for.
+ *
+ * Extracted from the submit guard in `chat-loop.ts` so the guard and the live
+ * budget view quote the same number instead of growing a second formula. It
+ * resolves through `resolveReservedOutputTokens`, which applies the configured
+ * output budget, the model's advertised cap, and the remaining-context clamp
+ * the `openai-completions` and `ollama-native` transports already perform on
+ * the wire. The capability-resolved cap is the input, because that is what the
+ * runtime resolution decided this target may actually be asked for.
+ *
+ * This is a preflight reservation, not a guarantee of the final wire ceiling:
+ * `remainingContextMaxTokens` re-derives the ceiling at request time against
+ * the context the transport is about to send.
+ *
+ * It is not the compaction-threshold reserve. `ContextSnapshot.categories.reserve`
+ * is window headroom held back so auto-compaction fires before a request is
+ * refused, and the two figures are unrelated.
+ */
+
+import { resolveReservedOutputTokens } from "../engine/apis/output-budget.js";
+import type { AgentRuntime } from "./turn-state.js";
+
+export function resolveTurnOutputReserve(agentRuntime: AgentRuntime, inputTokens: number): number {
+	// A runtime resolution always carries capability decisions in production. The
+	// optional read is for a partially built runtime: an absent cap is the
+	// resolver's own "no advertised limit" case, which falls back to the
+	// configured budget and then the product floor, rather than a crash on a path
+	// that now runs during ordinary accounting.
+	return resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions?.maxTokens, {
+		api: agentRuntime.agent.state.model?.api ?? "",
+		contextWindow: agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow,
+		inputTokens,
+	});
+}

package/src/interactive/overlay-session-lifecycle.ts

@@ -20,7 +20,7 @@ import type { ChatPanel } from "./chat-panel.js";
 import { rehydrateChatPanelFromTurns } from "./chat-renderer.js";
 import { emitCommandNotice } from "./command-fallbacks.js";
 import type { InteractiveNoticeLevel } from "./interactive-subscriptions.js";
-import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
+import { buildModelReplayAgentMessagesFromTurns, withContinuityReplay } from "./model-session-replay.js";
 import type { OverlayTransitions } from "./overlay-transitions.js";
 import { openCwdFallbackOverlay } from "./overlays/cwd-fallback.js";
 import { openHandoffReviewOverlay } from "./overlays/handoff-review.js";
@@ -188,7 +188,7 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 					// after it (a compaction summary covering the leaf, above all)
 					// still belong on screen. uptoTurnId is the historical-truncation
 					// variant `/tree` uses.
-					const replayOptions = leafTurnId ? { activeLeafTurnId: leafTurnId } : {};
+					const replayOptions = withContinuityReplay(turns, leafTurnId ? { activeLeafTurnId: leafTurnId } : {}, session);
 					deps.resetTranscript();
 					rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
 					const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, replayOptions);
@@ -240,8 +240,14 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 					if (!sessionId) throw new Error("no current session after turn switch");
 					const turns = deps.readStructuredEntries(sessionId);
 					deps.resetTranscript();
-					rehydrateChatPanelFromTurns(deps.chatPanel, turns, { uptoTurnId: turnId });
-					const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, { uptoTurnId: turnId });
+					// `uptoTurnId` truncates the display at the selected turn. It is
+					// deliberately not a continuity `historical` flag: a live /tree
+					// selection is still this session's own branch, and treating every
+					// display truncation as a historical fork would surrender ownership
+					// of its own transactions for good.
+					const replayOptions = withContinuityReplay(turns, { uptoTurnId: turnId }, session);
+					rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
+					const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, replayOptions);
 					deps.chat.resetForSession(turnId, replayMessages);
 					// The same branch the transcript above was just scoped to. Without the
 					// leaf, /usage, the footer Σ, and the last-turn line kept reporting the
@@ -324,12 +330,12 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 	function replayFork(forkedSessionId: string, parentTurnId: string, session: SessionContract): void {
 		try {
 			const turns = deps.readStructuredEntries(forkedSessionId);
-			rehydrateChatPanelFromTurns(deps.chatPanel, turns);
 			const leafTurnId = session.tree(forkedSessionId).leafId ?? parentTurnId;
-			const replayMessages = buildModelReplayAgentMessagesFromTurns(
-				turns,
-				leafTurnId ? { activeLeafTurnId: leafTurnId } : {},
-			);
+			// The child is already current here, so its own id and fork pointers are
+			// what separate the transactions it inherited from any it later mints.
+			const replayOptions = withContinuityReplay(turns, leafTurnId ? { activeLeafTurnId: leafTurnId } : {}, session);
+			rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
+			const replayMessages = buildModelReplayAgentMessagesFromTurns(turns, replayOptions);
 			deps.chat.resetForSession(leafTurnId, replayMessages);
 			rescopeToBranch(session, turns, leafTurnId);
 		} catch (error) {
@@ -617,8 +623,9 @@ export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps)
 		try {
 			const turns = deps.readStructuredEntries(toSessionId);
 			deps.resetTranscript();
-			rehydrateChatPanelFromTurns(deps.chatPanel, turns);
-			deps.chat.resetForSession(null, buildModelReplayAgentMessagesFromTurns(turns));
+			const replayOptions = withContinuityReplay(turns, {}, session);
+			rehydrateChatPanelFromTurns(deps.chatPanel, turns, replayOptions);
+			deps.chat.resetForSession(null, buildModelReplayAgentMessagesFromTurns(turns, replayOptions));
 			rescopeToBranch(session, turns, null);
 		} catch (error) {
 			deps.stderr(`[/handoff] seeding replay failed: ${error instanceof Error ? error.message : String(error)}\n`);

package/src/interactive/session-transcript.ts

@@ -3,7 +3,7 @@ import { collectSessionEntries } from "../domains/session/compaction/session-ent
 import type { SessionContract, SessionEntry } from "../domains/session/index.js";
 import { openSession, sessionPaths } from "../engine/session.js";
 import type { ChatLoop } from "./chat-loop.js";
-import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
+import { buildModelReplayAgentMessagesFromTurns, continuityContextFromSession } from "./model-session-replay.js";
 
 type SessionOwner = Pick<SessionContract, "create" | "current">;
 type SessionChat = Pick<ChatLoop, "resetForSession">;
@@ -89,6 +89,7 @@ export function createSessionTranscript(deps: SessionTranscriptDeps): SessionTra
 			leafTurnId,
 			buildModelReplayAgentMessagesFromTurns(turns, {
 				...(leafTurnId ? { activeLeafTurnId: leafTurnId } : {}),
+				continuity: continuityContextFromSession(deps.session),
 			}),
 		);
 		deps.refreshStatus();

package/src/interactive/slash-commands.ts

@@ -144,6 +144,7 @@ type SlashCommandVariant =
 	| { kind: "context-refresh" }
 	/** `ref` is the turnId an `[evicted ...]` marker names. */
 	| { kind: "context-recall"; ref: string }
+	| { kind: "context-recover"; handoffId: string; action: "reduce" | "deliver" }
 	| {
 			kind: "resources";
 			family?: "extensions" | "plugins";
@@ -823,6 +824,7 @@ export interface SlashCommandContext {
 	 * appends a compactionSummary entry. No-op when no session is open, so the
 	 * handler prints an actionable stderr line instead.
 	 */
+	runHandoffRecovery?: (handoffId: string, action: "reduce" | "deliver") => void;
 	runCompact: (instructions: string | undefined) => void;
 	/**
 	 * Escape hatch for the `view verify` entry: verify a receipt file on disk
@@ -1700,9 +1702,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		name: "context",
 		description: "Context hub: window overlay plus compact, recall, init, refresh, and reset",
 		group: "Inspect",
-		kinds: ["context-view", "compact", "context-recall", "init", "context-clear", "context-refresh"],
+		kinds: ["context-view", "compact", "context-recover", "context-recall", "init", "context-clear", "context-refresh"],
 		subcommandDescriptions: {
 			compact: "Compact session context",
+			recover: "Recover a paused handoff: ID reduce|deliver",
 			recall: "Recall an evicted result",
 			init: "Initialize project context",
 			refresh: "Refresh project context",
@@ -1711,6 +1714,12 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		args: {
 			subcommands: {
 				compact: { positionals: [...COMPACT_POSITIONALS] },
+				recover: {
+					positionals: [
+						{ name: "handoffId", required: true },
+						{ name: "action", required: true },
+					],
+				},
 				recall: { positionals: [...RECALL_POSITIONALS] },
 				init: {
 					flags: CONTEXT_INIT_FLAG_TABLE.flatMap(({ flag, aliases = [] }) => [flag, ...aliases].map((name) => ({ name }))),
@@ -1724,6 +1733,12 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			switch (parsed.subcommand) {
 				case "compact":
 					return { kind: "compact", instructions: parsed.rest };
+				case "recover": {
+					const [handoffId, action] = parsed.positionals;
+					return handoffId && (action === "reduce" || action === "deliver")
+						? { kind: "context-recover", handoffId, action }
+						: { kind: "usage-error", command: "context", reason: "Use /context recover <handoffId> <reduce|deliver>" };
+				}
 				case "recall":
 					return { kind: "context-recall", ref: parsed.positionals[0] ?? "" };
 				case "init": {
@@ -1752,6 +1767,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				case "compact":
 					ctx.runCompact(command.instructions);
 					return;
+				case "context-recover":
+					if (ctx.runHandoffRecovery) ctx.runHandoffRecovery(command.handoffId, command.action);
+					else ctx.notice("error", "native handoff recovery is unavailable");
+					return;
 				case "context-recall":
 					if (ctx.runContextRecall) {
 						ctx.runContextRecall(command.ref);