@iowarp/clio-coder 0.5.0 → 0.5.2

package/src/engine/agent.ts

@@ -1,4 +1,9 @@
-import { createInitialSystemMessage, toToolDeclaration } from "@earendil-works/pi-ai";
+import {
+	type AssistantMessage,
+	createAssistantMessageEventStream,
+	createInitialSystemMessage,
+	toToolDeclaration,
+} from "@earendil-works/pi-ai";
 import { resolvedRequestContext } from "./context.js";
 /**
  * Thin wrapper over Clio's engine Agent class.
@@ -13,12 +18,33 @@ import { resolvedRequestContext } from "./context.js";
  * Pi's resolved prompt/tool request view through streamFn.
  */
 
-import { Agent, type AgentOptions, type StreamFn } from "@earendil-works/pi-agent-core";
+import {
+	Agent,
+	type AgentMessage,
+	type AgentOptions,
+	type BeforeToolCallContext,
+	type StreamFn,
+} from "@earendil-works/pi-agent-core";
 import { isDispositionedToolResultError } from "../tools/result-disposition.js";
 import { engineStreamSimple } from "./api-registry.js";
 
 export type EngineStreamFn = (...args: Parameters<typeof engineStreamSimple>) => ReturnType<StreamFn>;
 
+/** Pi's settled-turn port, after all awaited result listeners. Replace context, not operator messages. */
+export type EnginePrepareNextTurnContext = Parameters<NonNullable<AgentOptions["prepareNextTurnWithContext"]>>[0];
+export type EnginePrepareNextTurnUpdate = Awaited<ReturnType<NonNullable<AgentOptions["prepareNextTurnWithContext"]>>>;
+export type EngineToolBatchContext = Pick<BeforeToolCallContext, "assistantMessage" | "context">;
+export interface EngineToolBatchRejection {
+	reason: string;
+}
+export interface EngineStreamRequest {
+	model: Parameters<StreamFn>[0];
+	/** Actual normalized transcript, after conversion and the final steering drain. Inspect only. */
+	context: Parameters<StreamFn>[1];
+	options: Parameters<StreamFn>[2];
+}
+export type EngineStreamAdmission = { block: true; reason: string } | { block: false; correlationId?: string };
+
 export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & {
 	/** Legacy/custom request view. Explicit overrides also replace the native hook in tests. */
 	streamFn?: EngineStreamFn;
@@ -26,11 +52,63 @@ export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & {
 	transcriptStreamFn?: StreamFn;
 	/** Called immediately before each native stream delegate invocation. */
 	onStreamInvocation?: () => void;
+	/** One fail-closed decision per assistant batch, before any valid sibling's per-call guard. */
+	beforeToolBatch?: (
+		context: EngineToolBatchContext,
+		signal?: AbortSignal,
+	) => EngineToolBatchRejection | undefined | Promise<EngineToolBatchRejection | undefined>;
+	/** Synchronous final admission: no suspension, reduction, request mutation, or model invocation. */
+	beforeStreamRequest?: (request: EngineStreamRequest) => EngineStreamAdmission;
 };
 
 export interface EngineAgentHandle {
 	agent: Agent;
 	state(): Agent["state"];
+	/** Exact emitted assistant object only. In-memory attribution, never proof of success or durability. */
+	requestCorrelationId(message: AgentMessage): string | undefined;
+}
+
+function batchAwareBeforeToolCall(
+	batch: NonNullable<EngineAgentOptions["beforeToolBatch"]>,
+	delegate: AgentOptions["beforeToolCall"],
+): NonNullable<AgentOptions["beforeToolCall"]> {
+	const decisions = new WeakMap<AssistantMessage, Promise<EngineToolBatchRejection | undefined>>();
+	return async (context, signal) => {
+		let decision = decisions.get(context.assistantMessage);
+		if (!decision) {
+			decision = Promise.resolve()
+				.then(() => batch({ assistantMessage: context.assistantMessage, context: context.context }, signal))
+				.catch(() => ({ reason: "Tool batch admission failed" }));
+			decisions.set(context.assistantMessage, decision);
+		}
+		const rejection = await decision;
+		if (rejection) return { block: true, reason: rejection.reason.slice(0, 1024) || "Tool batch rejected" };
+		return delegate?.(context, signal);
+	};
+}
+
+function refusedStream(request: EngineStreamRequest, reason: string, aborted = false): ReturnType<StreamFn> {
+	const stream = createAssistantMessageEventStream();
+	const message: AssistantMessage = {
+		role: "assistant",
+		content: [],
+		api: request.model.api,
+		provider: request.model.provider,
+		model: request.model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: aborted ? "aborted" : "error",
+		errorMessage: reason.slice(0, 1024) || "Request admission refused",
+		timestamp: Date.now(),
+	};
+	stream.push({ type: "error", reason: aborted ? "aborted" : "error", error: message });
+	return stream;
 }
 
 function dispositionAwareAfterToolCall(
@@ -46,17 +124,53 @@ function dispositionAwareAfterToolCall(
 }
 
 export function createEngineAgent(options: EngineAgentOptions = {}): EngineAgentHandle {
-	const { streamFn, transcriptStreamFn = engineStreamSimple, onStreamInvocation, ...agentOptions } = options;
+	const {
+		streamFn,
+		transcriptStreamFn = engineStreamSimple,
+		onStreamInvocation,
+		beforeToolBatch,
+		beforeStreamRequest,
+		...agentOptions
+	} = options;
+	const correlations = new WeakMap<AgentMessage, string>();
+	let activeCorrelationId: string | undefined;
+	const invoke: StreamFn = (model, context, streamOptions) => {
+		onStreamInvocation?.();
+		return streamFn
+			? streamFn(model, resolvedRequestContext(context), streamOptions)
+			: transcriptStreamFn(model, context, streamOptions);
+	};
+	const admit: StreamFn = (model, context, streamOptions) => {
+		if (!beforeStreamRequest) return invoke(model, context, streamOptions);
+		activeCorrelationId = undefined;
+		const request: EngineStreamRequest = { model, context, options: streamOptions };
+		let admission: EngineStreamAdmission;
+		try {
+			admission = beforeStreamRequest(request);
+		} catch {
+			return refusedStream(request, "Request admission failed", streamOptions?.signal?.aborted);
+		}
+		if (streamOptions?.signal?.aborted) return refusedStream(request, "Request aborted before invocation", true);
+		if (admission.block) return refusedStream(request, admission.reason);
+		activeCorrelationId = admission.correlationId;
+		return invoke(model, context, streamOptions);
+	};
 	const agent = new Agent({
 		...agentOptions,
-		streamFn: (model, context, streamOptions) => {
-			onStreamInvocation?.();
-			return streamFn
-				? streamFn(model, resolvedRequestContext(context), streamOptions)
-				: transcriptStreamFn(model, context, streamOptions);
-		},
+		streamFn: beforeStreamRequest ? admit : invoke,
+		...(beforeToolBatch ? { beforeToolCall: batchAwareBeforeToolCall(beforeToolBatch, options.beforeToolCall) } : {}),
 		afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall),
 	});
+	if (beforeStreamRequest) {
+		agent.subscribe((event) => {
+			if (event.type === "message_end" && event.message.role === "assistant" && activeCorrelationId !== undefined) {
+				correlations.set(event.message, activeCorrelationId);
+			}
+			if (event.type === "agent_start" || event.type === "turn_end" || event.type === "agent_end") {
+				activeCorrelationId = undefined;
+			}
+		});
+	}
 	// Pi correctly drops aborted assistants at the provider boundary: partial
 	// reasoning and tool calls are not valid provider history. Preserve the
 	// lifecycle fact and visible text as a host record instead, including on
@@ -83,6 +197,7 @@ export function createEngineAgent(options: EngineAgentOptions = {}): EngineAgent
 	return {
 		agent,
 		state: () => agent.state,
+		requestCorrelationId: (message) => correlations.get(message),
 	};
 }
 
@@ -99,3 +214,12 @@ export function replaceEngineMessages(
 export function setEngineSystemPrompt(agent: Agent, systemPrompt: string): void {
 	replaceEngineMessages(agent, agent.state.messages, systemPrompt);
 }
+
+/** Explicit host recovery can follow a terminal assistant. Empty input starts
+ * the native loop on the installed transcript without emitting a user message.
+ * Agent.continue() rejects that tail even when durable operator control already
+ * authorized another invocation. Normal tool continuation stays inside Pi.
+ */
+export function continueEngineWithoutInput(agent: Agent): Promise<void> {
+	return agent.prompt([]);
+}

package/src/engine/session.ts

@@ -62,19 +62,26 @@ export interface ClioSessionMeta {
 	platform: string;
 	nodeVersion: string;
 	/**
-	 * Version 4 on every new session. Readers reject earlier versions, sessions
+	 * Version 5 on every new session. Readers reject earlier versions, sessions
 	 * that omit this field, and versions from the future.
 	 */
 	sessionFormatVersion?: number;
 }
 
 /**
- * Version 4 adds the working-set ledger kinds (`contextEviction`,
- * `contextRecall`). A version-3 reader would parse those entries as unknown
- * kinds and replay a session as if nothing had been evicted, so the bump is
- * what makes an older Clio refuse the file instead of misreading it.
+ * Version 4 added the working-set ledger kinds (`contextEviction`,
+ * `contextRecall`). Version 5 adds the durable continuity kinds
+ * (`handoffTransaction`, `continuityCommit`) and the optional continuity
+ * payload a compaction summary carries.
+ *
+ * Each bump exists for the same reason: an older reader would parse the new
+ * records as unknown kinds and replay the session as if the state they record
+ * had never happened. A v4 build reading a v5 ledger would show no accepted
+ * handoff note and no paused transaction, so it refuses the file instead of
+ * misreading it. Both steps are additive to the ledger, so no historical entry
+ * is rewritten; only the metadata stamp moves.
  */
-export const CURRENT_SESSION_FORMAT_VERSION = 4;
+export const CURRENT_SESSION_FORMAT_VERSION = 5;
 
 export interface ClioSessionJsonlHeader {
 	type: "session";

package/src/entry/orchestrator.ts

@@ -65,11 +65,8 @@ import {
 } from "../domains/lifecycle/index.js";
 import { getVersionInfo } from "../domains/lifecycle/version.js";
 import {
-	buildMemoryPromptSection,
-	canonicalMemoryRepositoryIdentity,
 	createTaskMemoryTelemetrySink,
 	createTaskMemoryTrace,
-	loadMemoryRecordsSync,
 	proposeInjectedTaskMemory,
 	readTaskMemorySpendSummary,
 	renderTaskMemoryHandoffSource,
@@ -81,6 +78,7 @@ import {
 	taskMemoryHandoffSeedOffer,
 	taskMemoryTracePath,
 } from "../domains/memory/index.js";
+import { createMemoryPromptReader } from "../domains/memory/prompt-cache.js";
 import { TaskMemoryBank } from "../domains/memory/task-bank.js";
 import { TaskMemoryEndpointBusyError } from "../domains/memory/task-memory-policy.js";
 import { createDemoGuidanceRegistration } from "../domains/middleware/demo-guidance.js";
@@ -166,6 +164,8 @@ import type { CompactionCallObservation } from "../domains/session/compaction/co
 import { type CompactInput, type CompactResult, compact } from "../domains/session/compaction/compact.js";
 import { collectSessionEntries } from "../domains/session/compaction/session-entries.js";
 import { estimateTokens } from "../domains/session/compaction/tokens.js";
+import { continuityPayloadFromFold } from "../domains/session/continuity/carry.js";
+import { continuityProjectionTokens, resolveContinuityProjection } from "../domains/session/continuity/projection.js";
 import type { SessionContract, SessionMeta } from "../domains/session/contract.js";
 import { activeDecisionRefs, createDecisionBoardStore } from "../domains/session/decision-board.js";
 import type { CompactionSummaryEntry, CompactionTrigger, SessionEntry } from "../domains/session/entries.js";
@@ -205,7 +205,10 @@ import { cwdHash, openSession, readSessionTailTurns, sessionCurrentPath, session
 import type { EngineModel } from "../engine/types.js";
 import { createChatLoop } from "../interactive/chat-loop.js";
 import type { RunIo } from "../interactive/index.js";
-import { buildModelReplayAgentMessagesFromTurns } from "../interactive/model-session-replay.js";
+import {
+	buildModelReplayAgentMessagesFromTurns,
+	continuityContextFromSession,
+} from "../interactive/model-session-replay.js";
 import { prepareBackgroundModelMetadata } from "./background-model-metadata.js";
 import type { BootOptions } from "./boot-options.js";
 import { readCompactionSystemPrompt } from "./compaction-prompt.js";
@@ -824,7 +827,15 @@ async function runCompactionFlow(
 	instructions?: string,
 	trigger?: CompactionTrigger,
 	observability?: BackgroundMemoryUsageSink,
-	budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+	budget?: Pick<
+		CompactInput,
+		| "keepRecentTokens"
+		| "preserveUserTurnId"
+		| "skillContextState"
+		| "signal"
+		| "beforeSummaryCall"
+		| "checkpointForSummary"
+	>,
 	summarize?: CompactInput["summarize"],
 ): Promise<CompactResult | null> {
 	const meta = session.current();
@@ -837,6 +848,26 @@ async function runCompactionFlow(
 		session.current()?.id === meta.id && (session.tree(meta.id).leafId ?? undefined) === activeLeafTurnId;
 	const entries = filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId);
 	if (entries.length === 0) return null;
+	// Folded over the full applicable ledger before this compaction cuts it, so
+	// the carry written below reflects every durable transition, including ones
+	// older than the cut. Resolved once and used for three things: the payload
+	// the summary carries, the note's one-time price on both sides of the
+	// before/after comparison, and nothing else. Inspection never executes the
+	// action it proposes.
+	const continuity = resolveContinuityProjection({
+		entries,
+		sessionId: meta.id,
+		...(meta.parentSessionId && meta.parentTurnId
+			? { fork: { parentSessionId: meta.parentSessionId, parentTurnId: meta.parentTurnId } }
+			: {}),
+	});
+	// Only this session's own validated fold is carried forward. An inherited
+	// note is recall: writing it into this session's summary would republish
+	// another branch's transaction under this one's compaction.
+	const continuityNote = {
+		tokens: continuityProjectionTokens(continuity),
+		anchorTurnId: continuity.noteAnchorTurnId,
+	};
 	budget?.signal?.throwIfAborted();
 	const systemPrompt = await readCompactionSystemPrompt(settings.context.compaction.systemPrompt, meta.cwd);
 	budget?.signal?.throwIfAborted();
@@ -876,6 +907,7 @@ async function runCompactionFlow(
 	try {
 		result = await compact({
 			entries,
+			continuityNote,
 			...budget,
 			...(summarize ? { summarize } : {}),
 			onCall: (call) => calls.push(call),
@@ -912,6 +944,26 @@ async function runCompactionFlow(
 		result.usage = { ...result.usage, targetId: resolved.targetId, modelId: resolved.wireModelId };
 	}
 
+	// Refold before publishing the carry. The projection above was resolved
+	// before prompt loading, route resolution and the summary stream, and a
+	// transition appended during any of those awaits leaves the message leaf
+	// untouched, so the origin check just above passes while the carry in hand
+	// still says `ready`. §3 requires the summary to embed the *current*
+	// validated fold, so the ledger is re-read and refolded here. Only the carry
+	// is re-derived: `result` indexes the entry array the cut was computed
+	// against, which must not move under it.
+	const settledContinuity = resolveContinuityProjection({
+		entries: filterEntriesToActivePath(readSessionEntriesForCompact(meta.id), activeLeafTurnId),
+		sessionId: meta.id,
+		...(meta.parentSessionId && meta.parentTurnId
+			? { fork: { parentSessionId: meta.parentSessionId, parentTurnId: meta.parentTurnId } }
+			: {}),
+	});
+	// A suppressed projection publishes no authoritative carry: the adapter marks
+	// its own fold unvalidated, and `continuityPayloadFromFold` refuses one.
+	const continuityCarry =
+		settledContinuity.current === null ? null : continuityPayloadFromFold(settledContinuity.current);
+
 	const entry: Omit<CompactionSummaryEntry, "timestamp"> = {
 		kind: "compactionSummary",
 		turnId: randomUUID(),
@@ -923,12 +975,23 @@ async function runCompactionFlow(
 		firstKeptTurnId: result.firstKeptTurnId ?? "",
 		messagesSummarized: result.messagesSummarized,
 		isSplitTurn: result.isSplitTurn,
-		tokensAfter: estimateTokensAfterCompaction(entries, result),
+		tokensAfter: estimateTokensAfterCompaction(entries, result, continuityNote.tokens),
+		// The latest validated fold, carried so the transaction survives the cut
+		// that is about to remove its earlier records from replay. It preserves
+		// the immutable identity, accepted note, original policy and commit; it
+		// never manufactures a commit and never turns an eviction-only outcome
+		// into a summarized one. A later ordinary compaction with no handoff of
+		// its own still carries the newest validated payload forward, which is
+		// what keeps an eviction-only commit's state alive across summary cycles.
+		...(continuityCarry === null ? {} : { continuity: continuityCarry }),
 		// The summarization call is a real model call. Persisting its provider
-		// usage on the entry is what puts it in front of `/cost` and `clio-coder usage
+		// usage on the entry is what puts it in front of `/usage` and `clio-coder usage
 		// report`, which folded the ledger and so counted every call but this one.
 		...(result.usage !== undefined ? { usage: result.usage } : {}),
 	};
+	if (budget?.checkpointForSummary) {
+		entry.continuity = budget.checkpointForSummary(entry.turnId, entry.tokensBefore, entry.tokensAfter ?? 0);
+	}
 	if (trigger !== undefined) entry.trigger = trigger;
 	try {
 		session.appendEntry(entry);
@@ -986,7 +1049,15 @@ export function createProductionAutoCompact(
 ): (
 	instructions?: string,
 	trigger?: CompactionTrigger,
-	budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+	budget?: Pick<
+		CompactInput,
+		| "keepRecentTokens"
+		| "preserveUserTurnId"
+		| "skillContextState"
+		| "signal"
+		| "beforeSummaryCall"
+		| "checkpointForSummary"
+	>,
 ) => Promise<CompactResult | null> {
 	return (instructions, trigger, budget) =>
 		runCompactionFlow(session, getSettings(), providers, instructions, trigger, observability, budget, summarize);
@@ -1023,13 +1094,24 @@ function estimateTokensFromSummary(result: CompactResult): number {
  * still holds the assistant message whose usage describes the pre-compaction
  * prompt. Anchoring on it reports precisely the number compaction removed.
  */
-function estimateTokensAfterCompaction(entries: ReadonlyArray<SessionEntry>, result: CompactResult): number {
+function estimateTokensAfterCompaction(
+	entries: ReadonlyArray<SessionEntry>,
+	result: CompactResult,
+	/**
+	 * The projected continuity note, which survives the reduction and is
+	 * therefore on both sides. It is already inside `tokensBefore` and the
+	 * subtraction below never removes it, because continuity records estimate at
+	 * zero; it only has to be restored on the floor branch, which discards
+	 * `tokensBefore` entirely.
+	 */
+	continuityNoteTokens = 0,
+): number {
 	let droppedTokens = 0;
 	for (const entry of entries.slice(0, result.firstKeptEntryIndex)) droppedTokens += estimateTokens(entry);
 	const summaryTokens = estimateTokensFromSummary(result);
 	// The summary alone is the floor: a session whose dropped estimate exceeds
 	// the measured anchor must not report a negative or sub-summary context.
-	return Math.max(summaryTokens, result.tokensBefore - droppedTokens + summaryTokens);
+	return Math.max(summaryTokens + continuityNoteTokens, result.tokensBefore - droppedTokens + summaryTokens);
 }
 
 /**
@@ -1482,7 +1564,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	const memorySettings = (config?.get() ?? readSettings()).context.memory;
 	// Bound late: the registration is built here, but the buffer a deferred
 	// reminder lands in belongs to the chat loop that has not been composed yet.
-	let deferredMemoryReminderSink: ((message: string) => void) | null = null;
+	let deferredMemoryReminderSink: ((message: string, isCurrent?: () => boolean) => void) | null = null;
 	// The watchdog's findings are for the operator, not the model, so they take
 	// the transcript-notice path rather than the reminder buffer. Bound late for
 	// the same reason: the chat loop that owns the transcript is composed below.
@@ -1495,7 +1577,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	// check and the cost row read the same resolution the step itself used.
 	/**
 	 * Account for one background memory step exactly as a `/btw` side question is
-	 * accounted for: the in-process cost tracker under its own label so `/cost`
+	 * accounted for: the in-process cost tracker under its own label so `/usage`
 	 * shows it while the session lives, and one durable out-of-turn row so
 	 * `clio-coder usage report` can still see it afterwards.
 	 *
@@ -1537,7 +1619,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		// A headless run submits no further turn, so a detached step could only
 		// finish after the process that would have read it has exited.
 		deliversDeferredReminders: options.headless === undefined,
-		onDeferredReminder: (message) => deferredMemoryReminderSink?.(message),
+		onDeferredReminder: (message, isCurrent) => deferredMemoryReminderSink?.(message, isCurrent),
 		getSettings: () => {
 			const memory = effectiveSettingsForDispatch?.().context.memory ?? memorySettings;
 			return {
@@ -1790,6 +1872,8 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				})
 			: null;
 	const toolBootstrap = registerAllTools(toolRegistry, {
+		getContextBudget: () => chat.inspectLiveBudget(),
+		requestSelfCompact: (note, toolCallId, signal) => chat.requestSelfCompact(note, toolCallId, signal),
 		getSettings: () => getCurrentSettings(),
 		termination,
 		captureWorkerContext: () => chat.captureWorkerContext?.() ?? null,
@@ -2177,21 +2261,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		bus,
 		...(prompts ? { prompts } : {}),
 		...(session ? { session } : {}),
-		getMemorySection: () => {
-			try {
-				const records = loadMemoryRecordsSync(clioDataDir());
-				const settings = getCurrentSettings();
-				const targetId = session?.current()?.target ?? settings.chat?.target;
-				const runtimeId = targetId ? providers.getTarget(targetId)?.runtime : undefined;
-				return buildMemoryPromptSection(records, {
-					scopes: ["global", "repo", "runtime"],
-					activeRepository: canonicalMemoryRepositoryIdentity(process.cwd()),
-					activeRuntime: runtimeId === undefined ? null : { kind: "runtime", key: runtimeId },
-				}).section;
-			} catch {
-				return "";
-			}
-		},
+		getMemorySection: createMemoryPromptReader({ getDataDir: clioDataDir }),
 		getTaskMemoryHandoffSource: () => {
 			const meta = session?.current();
 			if (!meta) throw new Error("task memory handoff requires an active session");
@@ -2205,6 +2275,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				agentIds: [],
 			});
 		},
+		memoryCommitBridge: memoryIntervention,
 		registerDeferredReminderSink: (sink) => {
 			deferredMemoryReminderSink = sink;
 		},
@@ -2278,10 +2349,14 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				// parent onto.
 				chat.resetForSession(
 					leafTurnId,
-					buildModelReplayAgentMessagesFromTurns(
-						readCurrentSessionEntries(),
-						leafTurnId ? { activeLeafTurnId: leafTurnId } : {},
-					),
+					buildModelReplayAgentMessagesFromTurns(readCurrentSessionEntries(), {
+						...(leafTurnId ? { activeLeafTurnId: leafTurnId } : {}),
+						// The same ownership the interactive /resume overlay supplies.
+						// Without it this reader owns nothing, the fold finds no
+						// current origin, and a resumed session boots with its accepted
+						// note silently missing from the provider context.
+						continuity: continuityContextFromSession(session),
+					}),
 				);
 			} catch (err) {
 				chat.resetForSession(leafTurnId);
@@ -2332,8 +2407,15 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 				...(session
 					? {
 							readSessionEntries: readSessionEntriesForCompact,
+							// Ownership is read at call time, not captured: an ACP client
+							// can switch sessions between turns, and a fork opened this way
+							// must separate its own transactions from the ones it inherited
+							// exactly as the interactive path does.
 							buildReplayMessages: (entries: ReadonlyArray<SessionEntry>, leafTurnId: string | null) =>
-								buildModelReplayAgentMessagesFromTurns(entries, leafTurnId === null ? {} : { activeLeafTurnId: leafTurnId }),
+								buildModelReplayAgentMessagesFromTurns(entries, {
+									...(leafTurnId === null ? {} : { activeLeafTurnId: leafTurnId }),
+									continuity: continuityContextFromSession(session),
+								}),
 						}
 					: {}),
 				providers,
@@ -2788,6 +2870,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 							);
 						}
 					},
+					onRecoverHandoff: (handoffId, action) => chat.recoverHandoff(handoffId, action),
 					onCompact: async (instructions) => {
 						await chat.compact(instructions);
 					},

package/src/interactive/chat-loop-messages.ts

@@ -379,7 +379,7 @@ export interface RunUsageSummary {
  * messages. Earlier versions of this function walked the list from the tail
  * and returned the first match, which silently dropped every intermediate
  * API call from the cost tally. Summing instead matches what the provider
- * actually billed and keeps the `/cost` overlay and footer counters
+ * actually billed and keeps the `/usage` overlay and footer counters
  * aligned across tool-heavy runs.
  */
 export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSummary {
@@ -539,7 +539,7 @@ export function assistantSessionPayload(
  *
  * `estimated: true` is the provenance marker: no surface may report these as
  * provider-reported numbers. The usage fold and the context estimator both skip
- * aborted turns already, so this never reaches `/cost` or the window math; it is
+ * aborted turns already, so this never reaches `/usage` or the window math; it is
  * the record's own honesty about what the cancelled call cost.
  *
  * Returns null when the provider did report usage (there is nothing to fill in)