@iowarp/clio-coder 0.5.0 → 0.5.2

package/src/interactive/interactive-tickers.ts

@@ -1,3 +1,4 @@
+import type { UsageSnapshot } from "../domains/quota/types.js";
 import { type TaskBoardSnapshot, type TaskBoardStore, taskBoardCounts } from "../domains/session/task-board.js";
 import { Text, type TUI, visibleWidth, wrapTextWithAnsi } from "../engine/tui.js";
 import {
@@ -28,6 +29,7 @@ export interface InteractiveTickersDeps {
 	dispatchBoardStore: InteractiveDispatchStore;
 	contextActivityStore: InteractiveContextActivityStore;
 	getOverlayState: () => string;
+	getQuotaSnapshots?: () => ReadonlyArray<UsageSnapshot>;
 	isFooterExpanded: () => boolean;
 	/** Bound to TaskBoardStore.cachedSnapshot; repaint must never fold the session ledger. */
 	getTaskBoard?: TaskBoardStore["cachedSnapshot"];
@@ -126,7 +128,11 @@ export function createInteractiveTickers(deps: InteractiveTickersDeps): Interact
 		taskIslandHidden = hidden;
 		if (rows.length > 0)
 			taskIsland.setText(
-				formatTaskIslandLines(rows, Math.max(1, Math.min(4, Math.floor((taskIslandHeight - 8) / 9)))).join("\n"),
+				formatTaskIslandLines(
+					rows,
+					Math.max(1, Math.min(4, Math.floor((taskIslandHeight - 8) / 10))),
+					deps.getQuotaSnapshots?.() ?? [],
+				).join("\n"),
 			);
 		else if (board) taskIsland.setText(formatTaskBoardIslandLines(board).join("\n"));
 		taskIsland.invalidate();

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-general-openers.ts

@@ -23,7 +23,6 @@ import { formatUserTaskHandoff } from "../domains/user-tasks/handoff.js";
 import type { UserTasksStore } from "../domains/user-tasks/store.js";
 import type { TUI } from "../engine/tui.js";
 import { type OpenContextOverlayOptions, openContextOverlay } from "./context-overlay.js";
-import { openCostOverlay } from "./cost-overlay.js";
 import {
 	type createDispatchBoardView,
 	isDispatchBoardRowCancellable,
@@ -43,6 +42,7 @@ import { openFleetRunApprovalOverlay } from "./overlays/fleet-run-approval.js";
 import { openSideQuestionOverlay } from "./overlays/side-question.js";
 import type { ContextClearCommandOptions } from "./slash-commands.js";
 import { openTasksOverlay } from "./tasks-overlay.js";
+import { openUsageOverlay } from "./usage-overlay.js";
 import { type ArtifactProviderDeps, createDefaultArtifactProviders } from "./view/artifacts.js";
 import { openViewOverlay } from "./view/view-overlay.js";
 
@@ -51,6 +51,8 @@ export interface OverlayGeneralOpenersDeps {
 	tui: TUI;
 	transitions: OverlayTransitions;
 	observability: ObservabilityContract;
+	getQuotaSnapshots?: () => ReadonlyArray<import("../domains/quota/types.js").UsageSnapshot>;
+	getDispatchRows?: () => ReadonlyArray<import("./dispatch-board.js").DispatchBoardRow>;
 	getSessionId?: () => string | null;
 	getContextLedger: () => ContextLedger;
 	contextChat: NonNullable<OpenContextOverlayOptions["chat"]>;
@@ -80,7 +82,7 @@ export interface OverlayGeneralOpenersDeps {
 	startDispatchBoardTicker: () => void;
 	closeOverlay: () => void;
 	showOverlayFrame?: typeof showClioOverlayFrame;
-	openCostOverlay?: typeof openCostOverlay;
+	openUsageOverlay?: typeof openUsageOverlay;
 	openContextOverlay?: typeof openContextOverlay;
 	openContextResetOverlay?: typeof openContextResetOverlay;
 	openTasksOverlay?: typeof openTasksOverlay;
@@ -121,7 +123,7 @@ export interface OverlayGeneralOpenersDeps {
 }
 
 export interface OverlayGeneralOpeners {
-	openCost(): void;
+	openUsage(): void;
 	openContextView(): void;
 	openContextReset(): void;
 	toggleFooter(): void;
@@ -136,7 +138,7 @@ export interface OverlayGeneralOpeners {
 }
 
 export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): OverlayGeneralOpeners {
-	const openCostOverlayFactory = deps.openCostOverlay ?? openCostOverlay;
+	const openUsageOverlayFactory = deps.openUsageOverlay ?? openUsageOverlay;
 	const openContextOverlayFactory = deps.openContextOverlay ?? openContextOverlay;
 	const openContextResetOverlayFactory = deps.openContextResetOverlay ?? openContextResetOverlay;
 	const openTasksOverlayFactory = deps.openTasksOverlay ?? openTasksOverlay;
@@ -146,11 +148,13 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 	const showOverlayFrameFactory = deps.showOverlayFrame ?? showClioOverlayFrame;
 	const openSideQuestionOverlayFactory = deps.openSideQuestionOverlay ?? openSideQuestionOverlay;
 
-	const openCost = (): void => {
+	const openUsage = (): void => {
 		if (deps.transitions.state !== "closed") return;
-		deps.transitions.state = "cost";
-		deps.transitions.handle = openCostOverlayFactory(deps.tui, deps.observability, {
+		deps.transitions.state = "usage";
+		deps.transitions.handle = openUsageOverlayFactory(deps.tui, deps.observability, {
 			sessionId: deps.getSessionId?.() ?? null,
+			...(deps.getQuotaSnapshots ? { getQuotaSnapshots: deps.getQuotaSnapshots } : {}),
+			...(deps.getDispatchRows ? { getDispatchRows: deps.getDispatchRows } : {}),
 			...(deps.readSessionEntries
 				? {
 						getSessionEntries: () => deps.readSessionEntries?.() ?? [],
@@ -525,7 +529,7 @@ export function createOverlayGeneralOpeners(deps: OverlayGeneralOpenersDeps): Ov
 	};
 
 	return {
-		openCost,
+		openUsage,
 		openContextView,
 		openContextReset,
 		toggleFooter,

package/src/interactive/overlay-key-routing.ts

@@ -7,7 +7,7 @@ export type OverlayState =
 	| "permission-confirm"
 	| "dispatch-board"
 	| "auth"
-	| "cost"
+	| "usage"
 	| "context-view"
 	| "context-reset"
 	| "tasks"
@@ -213,8 +213,8 @@ function routeAuthOverlayKey(data: string, deps: CloseOverlayKeyDeps): boolean {
 	return false;
 }
 
-/** Pure overlay key router for the /cost overlay. Esc closes; everything else is swallowed. */
-function routeCostOverlayKey(data: string, deps: CloseOverlayKeyDeps): boolean {
+/** Esc closes an inspection overlay; callers decide how to route its remaining keys. */
+function routeReadOnlyOverlayKey(data: string, deps: CloseOverlayKeyDeps): boolean {
 	if (isEscapeKey(data)) {
 		deps.closeOverlay();
 		return true;
@@ -262,19 +262,16 @@ export function routeOverlayKey(
 		return true;
 	}
 	if (overlayState === "auth") return routeAuthOverlayKey(data, deps);
-	if (overlayState === "cost") {
-		routeCostOverlayKey(data, deps);
-		return true;
-	}
+	if (overlayState === "usage") return routeReadOnlyOverlayKey(data, deps);
 	if (overlayState === "context-view") {
-		routeCostOverlayKey(data, deps);
+		routeReadOnlyOverlayKey(data, deps);
 		return true;
 	}
 	// Esc is the only key the side-question overlay answers: it aborts a round
 	// that is still streaming and closes one that has settled. Everything else is
 	// swallowed so a keystroke cannot reach the composer behind it.
 	if (overlayState === "side-question") {
-		routeCostOverlayKey(data, deps);
+		routeReadOnlyOverlayKey(data, deps);
 		return true;
 	}
 	// The handoff review overlay owns Enter, `e`, the arrows, and Esc itself, so

package/src/interactive/overlay-lifecycle.ts

@@ -75,6 +75,8 @@ function interopProposalsFor(
 
 export interface OverlayLifecycleRuntimeDeps {
 	app: OverlayLifecycleApplicationDeps;
+	getQuotaSnapshots?: () => ReadonlyArray<import("../domains/quota/types.js").UsageSnapshot>;
+	getDispatchRows?: () => ReadonlyArray<import("./dispatch-board.js").DispatchBoardRow>;
 	tui: import("../engine/tui.js").TUI;
 	footer: import("./footer/dashboard.js").FooterDashboardPanel;
 	interactiveTickers: import("./interactive-tickers.js").InteractiveTickers;
@@ -117,7 +119,7 @@ export interface OverlayLifecycleRuntimeDeps {
 	openTreeOverlay?: typeof import("./overlays/tree-selector.js").openTreeOverlay;
 	openMessagePickerOverlay?: typeof import("./overlays/message-picker.js").openMessagePickerOverlay;
 	openCwdFallbackOverlay?: typeof import("./overlays/cwd-fallback.js").openCwdFallbackOverlay;
-	openCostOverlay?: typeof import("./cost-overlay.js").openCostOverlay;
+	openUsageOverlay?: typeof import("./usage-overlay.js").openUsageOverlay;
 	openContextOverlay?: typeof import("./context-overlay.js").openContextOverlay;
 	openContextResetOverlay?: typeof import("./overlays/context-reset.js").openContextResetOverlay;
 	openTasksOverlay?: typeof import("./tasks-overlay.js").openTasksOverlay;
@@ -140,7 +142,7 @@ export interface OverlayLifecycleController {
 	isAskUserWaiting(): boolean;
 	resetAskUserCancellation(): void;
 	refreshSettingsOverlay(): void;
-	openCostOverlayState(): void;
+	openUsageOverlayState(): void;
 	openContextViewOverlayState(): void;
 	openContextResetOverlayState(): void;
 	toggleFooterDashboardState(): void;
@@ -207,7 +209,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		openTreeOverlay: openTreeOverlayFactory,
 		openMessagePickerOverlay: openMessagePickerOverlayFactory,
 		openCwdFallbackOverlay: openCwdFallbackOverlayFactory,
-		openCostOverlay: openCostOverlayFactory,
+		openUsageOverlay: openUsageOverlayFactory,
 		openContextOverlay: openContextOverlayFactory,
 		openContextResetOverlay: openContextResetOverlayFactory,
 		openTasksOverlay: openTasksOverlayFactory,
@@ -417,6 +419,8 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		tui,
 		transitions: overlayTransitions,
 		observability: deps.app.observability,
+		...(deps.getQuotaSnapshots ? { getQuotaSnapshots: deps.getQuotaSnapshots } : {}),
+		...(deps.getDispatchRows ? { getDispatchRows: deps.getDispatchRows } : {}),
 		...(deps.app.getSessionId ? { getSessionId: deps.app.getSessionId } : {}),
 		getContextLedger: () => deps.app.chat.contextLedger(),
 		contextChat: deps.app.chat,
@@ -445,7 +449,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		startDispatchBoardTicker: () => interactiveTickers.startDispatchBoardTicker(),
 		closeOverlay,
 		showOverlayFrame,
-		...(openCostOverlayFactory ? { openCostOverlay: openCostOverlayFactory } : {}),
+		...(openUsageOverlayFactory ? { openUsageOverlay: openUsageOverlayFactory } : {}),
 		...(openContextOverlayFactory ? { openContextOverlay: openContextOverlayFactory } : {}),
 		...(openContextResetOverlayFactory ? { openContextResetOverlay: openContextResetOverlayFactory } : {}),
 		...(openTasksOverlayFactory ? { openTasksOverlay: openTasksOverlayFactory } : {}),
@@ -462,7 +466,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 	const openResumeOverlayState = overlaySessions.openResume;
 	const openTreeOverlayState = overlaySessions.openTree;
 	const openMessagePickerOverlayState = overlaySessions.openMessagePicker;
-	const openCostOverlayState = overlayGeneralOpeners.openCost;
+	const openUsageOverlayState = overlayGeneralOpeners.openUsage;
 	const openContextViewOverlayState = overlayGeneralOpeners.openContextView;
 	const openContextResetOverlayState = overlayGeneralOpeners.openContextReset;
 	const toggleFooterDashboardState = overlayGeneralOpeners.toggleFooter;
@@ -484,7 +488,7 @@ export function createOverlayLifecycle(deps: OverlayLifecycleRuntimeDeps): Overl
 		isAskUserWaiting: overlayAskUser.isWaiting,
 		resetAskUserCancellation: overlayAskUser.resetCancellation,
 		refreshSettingsOverlay: overlayModelSelectors.refreshSettingsOverlay,
-		openCostOverlayState,
+		openUsageOverlayState,
 		openContextViewOverlayState,
 		openContextResetOverlayState,
 		toggleFooterDashboardState,

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";
@@ -92,7 +92,7 @@ export interface OverlaySessionLifecycle {
 
 /**
  * The target and model a session started under, so reseeded calls land in the
- * same `/cost` bucket the live path writes to. Without it a single target read
+ * same `/usage` bucket the live path writes to. Without it a single target read
  * as two providers, one under the target id and one under the runtime name.
  */
 function sessionUsageDefaults(session: SessionContract): { target?: string | null; model?: string | null } {
@@ -120,7 +120,7 @@ function restorePriorSessionOrReopen(
 
 export function createOverlaySessionLifecycle(deps: OverlaySessionLifecycleDeps): OverlaySessionLifecycle {
 	/**
-	 * Point every running number the footer and `/cost` show at one branch. The
+	 * Point every running number the footer and `/usage` show at one branch. The
 	 * session total and the last-turn line are read off the same lineage in the
 	 * same call, so a switch cannot move one and leave the other behind.
 	 */
@@ -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,11 +240,17 @@ 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, /cost, the footer Σ, and the last-turn line kept reporting the
+					// leaf, /usage, the footer Σ, and the last-turn line kept reporting the
 					// abandoned turns.
 					rescopeToBranch(session, turns, turnId);
 				} catch (error) {
@@ -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`);