@estebanforge/pi-antigravity-bridge 1.3.3 → 1.4.1

package/src/driver.ts

@@ -16,81 +16,29 @@
 
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { parseAgyLine, type AgyUsage } from "./stream-events.js";
+import { parseAgyLine } from "./stream-events.js";
 import { bridgeMcpConfigDir, bridgeMcpConfigExists } from "./mcp-server.js";
-
-export type DriverState = "idle" | "starting" | "ready" | "running" | "dead";
-
-export interface DriverProfile {
-	cwd: string;
-	model: string;
-	effort?: string;
-	mode: string;
-	skipPermissions: boolean;
-}
-
-export interface DriverTurnRequest extends DriverProfile {
-	/** Existing agy conversation to resume (`--conversation`). */
-	conversationId?: string | null;
-	prompt: string;
-	signal?: AbortSignal;
-	/** Overall turn cap in minutes (default 10). */
-	timeoutMin?: number;
-	/** Stdout inactivity cap in minutes (default 5). */
-	inactivityMin?: number;
-}
-
-export type DriverActivity =
-	| { type: "text"; delta: string }
-	| { type: "thought"; tokens: number }
-	| { type: "tool_start"; stepId?: number; name: string; args: Record<string, unknown> }
-	| {
-			type: "tool_done";
-			stepId?: number;
-			name: string;
-			args: Record<string, unknown>;
-			output?: string;
-			durationSeconds?: number;
-	  }
-	| { type: "tool_error"; stepId?: number; name: string; message: string }
-	| { type: "usage"; usage: AgyUsage }
-	/** Synthetic: injected by the provider when the MCP bridge receives a call. */
-	| { type: "bridge_call"; callId: string; name: string; args: Record<string, unknown> };
-
-export interface TurnOutcome {
-	conversationId?: string;
-	status: "OK" | "ERROR" | "UNKNOWN";
-	response: string;
-	error?: string;
-	usage?: AgyUsage;
-	finished: boolean;
-	aborted: boolean;
-}
-
-export interface TurnHandle {
-	id: string;
-	/** Resolves when the turn settles (result event, exit, abort, recycle). */
-	outcome: Promise<TurnOutcome>;
-	/** Pull the next activity. Resolves null once the activity stream closes. */
-	next(): Promise<DriverActivity | null>;
-	/** Inject a synthetic activity (bridge inbox). No-op after settle. */
-	pushExternal(activity: DriverActivity): void;
-}
-
-export interface DriverSnapshot {
-	state: DriverState;
-	pid?: number;
-	conversationId?: string;
-	stats: {
-		spawns: number;
-		turns: number;
-		reused: number;
-		recycles: number;
-		lastRecycleReason?: string;
-		recycleReasons: Record<string, number>;
-	};
-	lifecycle: string[];
-}
+import type {
+	AgyUsage,
+	DriverActivity,
+	DriverProfile,
+	DriverSnapshot,
+	DriverState,
+	DriverTurnRequest,
+	TurnDriver,
+	TurnHandle,
+	TurnOutcome,
+} from "./driver-types.js";
+
+export type {
+	DriverActivity,
+	DriverProfile,
+	DriverSnapshot,
+	DriverState,
+	DriverTurnRequest,
+	TurnHandle,
+	TurnOutcome,
+} from "./driver-types.js";
 
 const LIFECYCLE_LIMIT = 24;
 const THINKING_TOKEN_FLOOR = 64;
@@ -163,7 +111,18 @@ export function isCumulativeResend(accumulated: string, next: string): boolean {
 	return accumulated.length > 0 && next.length > accumulated.length && next.startsWith(accumulated);
 }
 
-export class AgyDriver {
+/** Flip threshold for the same guard: short accumulations ("**", "#", "\n")
+ *  are trivially extended by ordinary markdown deltas, and flipping on them
+ *  corrupts every remaining frame of the turn. Require a respectable
+ *  accumulation before believing a resend. Exported for tests. */
+export const CUMULATIVE_FLIP_MIN_CHARS = 32;
+
+/** Mode decision for the text-dedupe guard. Extracted for tests. */
+export function shouldFlipToCumulative(accumulated: string, next: string): boolean {
+	return accumulated.length >= CUMULATIVE_FLIP_MIN_CHARS && isCumulativeResend(accumulated, next);
+}
+
+export class AgyDriver implements TurnDriver {
 	#state: DriverState = "idle";
 	#child: ChildProcess | undefined;
 	#generation = 0;
@@ -173,6 +132,10 @@ export class AgyDriver {
 	#queueTail: Promise<void> = Promise.resolve();
 	#shutdown = false;
 	#stderrTail = "";
+	// Frames can split across pipe chunks; the trailing partial line lives here
+	// until its newline arrives (same scheme as JsonRpcSession.feed). Dropping
+	// it ate large tool frames and could hide the result frame of a turn.
+	#stdoutBuf = "";
 	#lifecycle: string[] = [];
 	#onTurnEnd: ((outcome: TurnOutcome) => void) | undefined;
 	#stats = {
@@ -373,7 +336,16 @@ export class AgyDriver {
 			windowsHide: true,
 		});
 		this.#child = child;
+		this.#stdoutBuf = "";
 		this.#stats.spawns += 1;
+		// Pipe write failures surface asynchronously as stream 'error' events;
+		// the sync try/catch around stdin.write cannot see them. Without this
+		// listener an EPIPE (agy died mid-write) is uncaught and kills pi.
+		child.stdin!.on("error", (err) => {
+			if (generation !== this.#generation) return;
+			const turn = this.#active;
+			if (turn && !turn.closed) this.#failTurn(turn, `agy stdin write failed: ${err.message}`);
+		});
 		this.#log(`spawn:${child.pid ?? "?"}:${request.conversationId ? "resume" : "fresh"}`);
 		this.#state = "ready";
 
@@ -420,10 +392,15 @@ export class AgyDriver {
 	}
 
 	#onStdout(chunk: string): void {
+		// Buffer the trailing partial line: a frame split across pipe chunks is
+		// reassembled when its newline arrives (mirrors JsonRpcSession.feed).
+		this.#stdoutBuf += chunk;
+		const lines = this.#stdoutBuf.split("\n");
+		this.#stdoutBuf = lines.pop() ?? "";
 		const turn = this.#active;
 		if (!turn || turn.closed) return;
 		if (turn.idleTimer) turn.idleTimer.refresh();
-		for (const line of chunk.split("\n")) {
+		for (const line of lines) {
 			if (!line.trim()) continue;
 			this.#applyParsed(turn, parseAgyLine(line));
 			if (turn.closed) return;
@@ -525,13 +502,26 @@ export class AgyDriver {
 	#appendAgentText(turn: ActiveTurn, text: string): void {
 		// response_text is observed as a delta stream; guard against builds that
 		// resend the full text. A cumulative sender's second chunk CONTAINS
-		// everything accumulated so far as a prefix.
+		// everything accumulated so far as a prefix. Two guards against
+		// misflips (round-7 review): short accumulations never flip, and a
+		// cumulative frame that no longer extends the accumulator is evidence
+		// of a misflip - fall back to append mode.
 		if (turn.cumulativeText === undefined) {
 			turn.cumulativeText = false;
-		} else if (!turn.cumulativeText && isCumulativeResend(turn.response, text)) {
+		} else if (
+			!turn.cumulativeText &&
+			shouldFlipToCumulative(turn.response, text)
+		) {
 			turn.cumulativeText = true;
 		}
 		if (turn.cumulativeText) {
+			if (!text.startsWith(turn.response)) {
+				// Misflip evidence: back to deltas.
+				turn.cumulativeText = false;
+				turn.response += text;
+				emit(turn, { type: "text", delta: text });
+				return;
+			}
 			if (text.length > turn.response.length) {
 				const delta = text.slice(turn.response.length);
 				turn.response = text;
@@ -613,6 +603,7 @@ export class AgyDriver {
 		if (!child) return;
 		this.#child = undefined;
 		this.#generation += 1;
+		this.#stdoutBuf = "";
 		try {
 			child.stdout?.removeAllListeners();
 			child.stderr?.removeAllListeners();

package/src/mcp-server.ts

@@ -37,11 +37,17 @@ import {
 const SKIP_CIRCULAR = new Set(["AskAntigravity"]);
 
 const BRIDGE_MCP_KEY = "pi-antigravity-bridge";
-const TOKEN_HEADER = "x-bridge-token";
+/** Shared-secret header every bridge request must carry. Exported: the ACP
+ *  engine's mcpServers registration needs the same header name (the legacy
+ *  engine gets it via .agents/mcp_config.json; ACP gets it via headers[]). */
+export const TOKEN_HEADER = "x-bridge-token";
 const MAX_BODY_BYTES = 1_000_000;
 
 export interface McpServerHandle {
 	port: number;
+	/** Shared secret for TOKEN_HEADER. Callers that register the bridge with
+	 *  an engine other than the legacy stream-json discovery file need it. */
+	token: string;
 	close: () => Promise<void>;
 }
 
@@ -409,6 +415,7 @@ export async function startMcpServer(
 				port,
 				handle: {
 					port,
+					token,
 					close: async () => {
 						await new Promise<void>((r) => httpServer.close(() => r()));
 						removeBridgeMcpConfig();

package/src/models.ts

@@ -273,8 +273,11 @@ function thinkingLevelMapFor(efforts: readonly AgyEffort[]): ThinkingLevelMap {
 	return map as ThinkingLevelMap;
 }
 
-/** Project an agy entry to pi's Model shape. */
-export function toPiModel(entry: AgyModelEntry): Model<Api> {
+/** Project an agy entry to pi's Model shape. `input` advertises accepted
+ *  inputs: text-only (default) or text+image. The ACP engine forwards image
+ *  blocks natively (probe 2026-09-03); the legacy CLI prompt is text-only, so
+ *  the extension decides by engine at load time. */
+export function toPiModel(entry: AgyModelEntry, input: Array<"text" | "image"> = ["text"]): Model<Api> {
 	const effortDriven = !!entry.efforts && entry.efforts.length > 0;
 	return {
 		id: entry.id,
@@ -290,11 +293,10 @@ export function toPiModel(entry: AgyModelEntry): Model<Api> {
 		// changed and agy rejects --effort for them.
 		reasoning: effortDriven,
 		...(effortDriven ? { thinkingLevelMap: thinkingLevelMapFor(entry.efforts!) } : {}),
-		// agy's -p prompt is text-only. Advertising image input would let pi
-		// offer image attach, but extractUserPrompt silently drops image blocks,
-		// so the user would be misled. Keep input text-only until agy supports
-		// image passthrough in print mode.
-		input: ["text"],
+		// Input advertising comes from the caller (engine-dependent): the ACP
+		// engine forwards image blocks; advertising images on the legacy engine
+		// would let pi offer image attach only for them to be dropped.
+		input,
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 		// Gemini long context. agy doesn't expose the real per-model window in
 		// `agy models`; 1M is the documented Gemini ceiling.

package/src/provider.ts

@@ -28,15 +28,16 @@ import {
 	type ThinkingLevel,
 	type Usage,
 } from "@earendil-works/pi-ai";
+import fs from "node:fs";
 import type { Api } from "@earendil-works/pi-ai";
-import { AgyDriver, type DriverActivity, type TurnHandle } from "./driver.js";
+import type { DriverActivity, TurnDriver, TurnHandle } from "./driver-types.js";
 import { toPiUsage } from "./stream-events.js";
 import { mapAgyToolToNative } from "./native-tools.js";
 import { type AgyEffort, type AgyModelEntry } from "./models.js";
 import { SessionStore } from "./sessions.js";
 import { loadConfig } from "./config.js";
 import path from "node:path";
-import { TurnDiffContext, createExecGitOps, parseEditToolInput } from "./diff-render.js";
+import { TurnDiffContext, createExecGitOps, formatInlineDiff, parseEditToolInput } from "./diff-render.js";
 
 const DEFAULT_TIMEOUT_MIN = 10;
 
@@ -61,7 +62,7 @@ function extractUserPrompt(context: Context): string | null {
 	if (!last || last.role !== "user") return null;
 	const content = last.content;
 	if (typeof content === "string") return content;
-	// Flatten text blocks; drop images (agy CLI prompt is text-only via -p).
+	// Flatten text blocks; images ride separately via extractImages (ACP only).
 	return content
 		.filter((b): b is { type: "text"; text: string } => b.type === "text")
 		.map((b) => b.text)
@@ -69,6 +70,17 @@ function extractUserPrompt(context: Context): string | null {
 		.trim() || null;
 }
 
+/** Image blocks of the latest user message (pi-ai ImageContent: base64 data
+ *  + mimeType). The ACP engine forwards them as typed content blocks; the
+ *  legacy CLI prompt is text-only, so its driver simply ignores these. */
+function extractImages(context: Context): Array<{ data: string; mimeType: string }> {
+	const last = context.messages[context.messages.length - 1];
+	if (!last || last.role !== "user" || typeof last.content === "string") return [];
+	return last.content
+		.filter((b): b is { type: "image"; data: string; mimeType: string } => b.type === "image")
+		.map((b) => ({ data: b.data, mimeType: b.mimeType }));
+}
+
 // --- G1: pi-side context digest --------------------------------------------------
 //
 // agy keeps its OWN conversation history (resumed via --conversation), so it
@@ -264,9 +276,17 @@ function newAssistant(model: Model<Api>): AssistantMessage {
 
 /** Session key: prefer pi's sessionId (stable per conversation), fall back to
  *  cwd so a single pi process still resumes correctly when sessionId is absent. */
-function sessionKey(options: SimpleStreamOptions | undefined, cwd: string): string {
+function sessionKey(
+	options: SimpleStreamOptions | undefined,
+	cwd: string,
+	engine: "stream-json" | "acp",
+): string {
 	const sid = (options as { sessionId?: string } | undefined)?.sessionId;
-	return sid && sid.length > 0 ? `sid:${sid}` : `cwd:${cwd}`;
+	const base = sid && sid.length > 0 ? `sid:${sid}` : `cwd:${cwd}`;
+	// Engine-scoped keys (plan 9.4): one ACP turn must never touch the legacy
+	// binding and vice versa. Un-suffixed keys = legacy, byte-compatible with
+	// every store that predates the ACP engine.
+	return base + (engine === "acp" ? "@acp" : "");
 }
 
 /** Track which content block is currently open so we close-on-switch.
@@ -281,9 +301,13 @@ export interface BlockState {
 export interface StreamSimpleDeps {
 	entries: AgyModelEntry[];
 	store: SessionStore;
-	/** Persistent stream-json driver. Turns run on the driver and bridge
-	 *  calls park as toolUse round-trips. Required with roundTrips. */
-	driver?: AgyDriver;
+	/** Legacy stream-json driver (the tested default engine). Turns run on the
+	 *  driver and bridge calls park as toolUse round-trips. Required with
+	 *  roundTrips. */
+	driver?: TurnDriver;
+	/** Official-server ACP engine. Opt-in via config.engine = "acp"; when
+	 *  absent the config switch falls back to the legacy driver. */
+	acpDriver?: TurnDriver;
 	roundTrips?: ToolRoundTrips;
 	/** Replay store for the display-only antigravity wrapper tool. Required
 	 *  for native re-exec and wrapper cards; without it tool steps render as
@@ -292,6 +316,10 @@ export interface StreamSimpleDeps {
 	/** Whether a pi tool is active in the session; native re-exec toolCalls
 	 *  are only emitted for active builtins (else the wrapper). */
 	nativeActive?: (name: string) => boolean;
+	/** Engine latched at extension load. When omitted, the per-call config
+	 *  read decides (tests); production wiring always passes it so a
+	 *  mid-session config flip cannot move one side of a parked turn. */
+	engine?: "stream-json" | "acp";
 }
 
 /** pi thinking-effort order mirrors agy's, for clamping. */
@@ -390,11 +418,13 @@ export class WrapperReplay {
 
 export class ToolRoundTrips {
 	#pending = new Map<string, PendingRoundTrip>();
-	#driver: AgyDriver;
+	#getDriver: () => TurnDriver;
 	#log: (s: string, d?: unknown) => void;
 
-	constructor(driver: AgyDriver, log?: (s: string, d?: unknown) => void) {
-		this.#driver = driver;
+	/** Accepts a driver or a getter: with two engines wired, the ACTIVE driver
+	 *  is resolved at call time from config (plan §9.5). */
+	constructor(driver: TurnDriver | (() => TurnDriver), log?: (s: string, d?: unknown) => void) {
+		this.#getDriver = typeof driver === "function" ? driver : () => driver;
 		this.#log = log ?? (() => {});
 	}
 
@@ -419,7 +449,7 @@ export class ToolRoundTrips {
 		clearTimeout(entry.timer);
 		if (entry.onAbort && entry.signal) entry.signal.removeEventListener("abort", entry.onAbort);
 		entry.reject!(new Error(reason));
-		this.#driver.kickIdle();
+		this.#getDriver().kickIdle();
 		this.#log("round-trip-fail", { callId, name: entry.name, reason });
 	}
 
@@ -431,7 +461,7 @@ export class ToolRoundTrips {
 		args: Record<string, unknown>,
 		signal: AbortSignal,
 	): Promise<BridgeCallResultShape> => {
-		const handle = this.#driver.activeHandle;
+		const handle = this.#getDriver().activeHandle;
 		if (!handle) {
 			return Promise.reject(
 				new Error(
@@ -469,7 +499,7 @@ export class ToolRoundTrips {
 			return true;
 		}
 		entry.resolve!({ content: [{ type: "text", text }], isError });
-		this.#driver.kickIdle();
+		this.#getDriver().kickIdle();
 		this.#log("round-trip-resolved", { callId: toolCallId, name: entry.name, isError });
 		return true;
 	}
@@ -495,10 +525,12 @@ export function collectToolResults(
 // --- stream-json engine -------------------------------------------------------
 
 export interface DriverDeps {
-	driver: AgyDriver;
+	driver: TurnDriver;
 	roundTrips: ToolRoundTrips;
 	replay?: WrapperReplay;
 	nativeActive?: (name: string) => boolean;
+	/** Active engine (config), for engine-scoped session keys. */
+	engine: "stream-json" | "acp";
 }
 
 /** Map one DriverActivity onto the open pi stream. Returns "parked" when the
@@ -507,6 +539,7 @@ export interface ActivityFeatures {
 	replay?: WrapperReplay;
 	nativeActive?: (name: string) => boolean;
 	roundTrips?: ToolRoundTrips;
+	engine?: "stream-json" | "acp";
 }
 
 /** Process-wide counter: round-trip ids must never repeat across turns in
@@ -537,6 +570,12 @@ function emitToolUse(
 	stream.end();
 }
 
+/** ACP edit-class tool names that carry a file-path arg and land the file on
+ *  disk (observed live: edit_file, create_file). Read/execute tools also
+ *  match the arg-shape heuristic but produce no diff (unchanged content), so
+ *  the gate avoids mislabeling them as edits. */
+const ACP_EDIT_TOOLS = new Set(["edit_file", "create_file", "write_to_file"]);
+
 export function consumeActivity(
 	stream: AssistantMessageEventStream,
 	blocks: BlockState,
@@ -551,7 +590,11 @@ export function consumeActivity(
 			appendText(stream, blocks, activity.delta);
 			return "continue";
 		case "thought":
-			// agy reports a token count only; no text body to render.
+			// Legacy: token count only (no body). ACP: thought TEXT deltas —
+			// rendered through the same thinking block pipeline (9.2).
+			if (typeof activity.delta === "string" && activity.delta.length > 0) {
+				appendThinking(stream, blocks, activity.delta);
+			}
 			return "continue";
 		case "usage":
 			toPiUsage(activity.usage, partial.usage);
@@ -559,8 +602,51 @@ export function consumeActivity(
 		case "tool_start":
 			// Rendering happens on completion (output/diff available).
 			return "continue";
+/** File-path argument of an ACP edit tool (observed: `file_path`); other
+ *  tool kinds (execute, read) don't carry one. Returns undefined for
+ *  non-edit tools. */
+function acpEditFileArg(args: Record<string, unknown>): string | undefined {
+	for (const [k, v] of Object.entries(args)) {
+		if (typeof v === "string" && v.trim() && /file|path/i.test(k)) return v;
+	}
+	return undefined;
+}
+
 		case "tool_done": {
-			// G8: agy file edits surface a git-sourced diff in a thinking block.
+			// Gate C (ACP): the server already executed the tool; nothing parks.
+			// Edit display has TWO paths on ACP:
+			//   a) native diff in tool_call content[] (future builds / the
+			//      permission-request flow carries it; phase-2 probe shape);
+			//   b) RC01 with the auto policy sends NO content: the file simply
+			//      lands on disk. Read it and diff against git HEAD - the same
+			//      output the stream-json engine produces, one readFileSync.
+			if (feats.engine === "acp") {
+				const d = activity.diff;
+				if (d) {
+					appendThinking(stream, blocks, `[agy edit: ${path.basename(d.path)}]\n`);
+					const diffText = formatInlineDiff(d.oldText ?? "", d.newText);
+					if (diffText) appendThinking(stream, blocks, `${diffText}\n`);
+					return "continue";
+				}
+				const editFile = ACP_EDIT_TOOLS.has(activity.name) ? acpEditFileArg(activity.args) : undefined;
+				if (editFile) {
+					const absFile = path.isAbsolute(editFile) ? editFile : path.resolve(cwd, editFile);
+					appendThinking(stream, blocks, `[agy edit: ${path.basename(absFile)}]\n`);
+					let disk = "";
+					try {
+						disk = fs.readFileSync(absFile, "utf8");
+					} catch {
+						/* deleted or unreadable: diffEdit degrades to a summary */
+					}
+					const outcome = diffCtx.diffEdit(absFile, disk);
+					if (outcome.text) appendThinking(stream, blocks, `${outcome.text}\n`);
+					return "continue";
+				}
+				appendThinking(stream, blocks, `[agy tool: ${activity.name}]\n`);
+				return "continue";
+			}
+			// G8 (stream-json): agy file edits surface a git-sourced diff in a
+			// thinking block. The server sends no diff here, so OLD comes from git.
 			let inputJson: string | undefined;
 			try {
 				inputJson = JSON.stringify(activity.args);
@@ -629,7 +715,7 @@ async function runTurnDriver(
 	const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
 
 	const cwd = (options as { cwd?: string } | undefined)?.cwd ?? process.cwd();
-	const key = sessionKey(options, cwd);
+	const key = sessionKey(options, cwd, deps.engine);
 	const existing = store.get(key);
 	const messageCount = context.messages.length;
 	const config = loadConfig();
@@ -651,7 +737,10 @@ async function runTurnDriver(
 		handle = active;
 	} else {
 		const prompt = extractUserPrompt(context);
-		if (!prompt) {
+		const images = extractImages(context);
+		// An image-only message (no text) is valid on the ACP engine; only fail
+		// when there is nothing at all to send.
+		if (!prompt && images.length === 0) {
 			finalize(stream, blocks, "error", "No user message to send to agy.");
 			return;
 		}
@@ -660,11 +749,20 @@ async function runTurnDriver(
 		const effort = entry?.efforts?.length ? toAgyEffort(options?.reasoning, entry.efforts) : undefined;
 		const watermark = existing?.lastMessageCount ?? 0;
 		const digest = config.digest ? buildContextDigest(context.messages, watermark) : "";
+		// G1 delivery per engine. stream-json: digest rides inline in the prompt
+		// (the CLI has no context channel). ACP: the server advertises
+		// `embeddedContext`, so the digest ships as a native resource block
+		// instead of prompt text (plan phase 3). The preamble framing goes INTO
+		// the block: an unlabeled blob of other-agent turns is a mild injection
+		// surface, and the model needs the use-for-continuity-only instruction.
+		// The uri is suffixed per turn so a deduping server cannot serve stale
+		// content on turn 2+.
+		const embeddedDigest = deps.engine === "acp" && digest ? digest : undefined;
 		// Fresh conversation only: agy stores the block in its own history, so
 		// re-sending it every turn would bloat each prompt and bust the cache.
 		const sysPrompt =
 			config.systemPrompt && !existing?.conversationId ? context.systemPrompt : undefined;
-		const fullPrompt = buildFullPrompt(sysPrompt, digest, prompt);
+		const fullPrompt = buildFullPrompt(sysPrompt, embeddedDigest ? "" : digest, prompt ?? "");
 		try {
 			handle = await deps.driver.run({
 				cwd,
@@ -674,6 +772,13 @@ async function runTurnDriver(
 				skipPermissions: config.skipPermissions,
 				conversationId: existing?.conversationId ?? null,
 				prompt: fullPrompt,
+				images: images.length > 0 ? images : undefined,
+				contextBlock: embeddedDigest
+					? {
+							uri: `urn:pi-bridge:context-digest/${messageCount}`,
+							text: `${DIGEST_PREAMBLE}\n\n${embeddedDigest}`,
+						}
+					: undefined,
 				signal: options?.signal,
 			});
 		} catch (err) {
@@ -689,6 +794,7 @@ async function runTurnDriver(
 		replay: deps.replay,
 		nativeActive: deps.nativeActive,
 		roundTrips: deps.roundTrips,
+		engine: deps.engine,
 	};
 
 	for (;;) {
@@ -729,17 +835,36 @@ async function runTurnDriver(
 export function createStreamSimple(
 	deps: StreamSimpleDeps,
 ): (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream {
-	const { entries, store, driver, roundTrips } = deps;
+	const { entries, store, roundTrips } = deps;
 
 	return function streamSimple(model, context, options) {
 		const stream = createAssistantMessageEventStream();
 		// Fire the async turn; return the stream synchronously per pi's contract.
-		if (driver && roundTrips) {
+		// Engine selection: the latched load-time engine when the extension
+		// provides one, else the per-call config read (tests). One loadConfig()
+		// read per turn, shared with the session key below.
+		const config = loadConfig();
+		const engine = deps.engine ?? config.engine;
+		const selected = engine === "acp" && deps.acpDriver ? deps.acpDriver : deps.driver;
+		// RC01: ACP modes are permission modes, there is no review-only plan.
+		// A plan turn on ACP would silently run non-plan; fail visibly instead.
+		if (selected === deps.acpDriver && config.mode === "plan") {
+			const partial = newAssistant(model);
+			const blocks: BlockState = { partial, textIdx: null, thinkingIdx: null, started: false };
+			finalize(stream, blocks, "error", "ACP engine has no plan mode. /agy mode accept-edits, or /agy engine stream-json.");
+			return stream;
+		}
+		if (selected && roundTrips) {
 			void runTurnDriver(stream, model, context, options, entries, store, {
-				driver,
+				driver: selected,
 				roundTrips,
 				replay: deps.replay,
 				nativeActive: deps.nativeActive,
+				// Record the engine of the driver that will ACTUALLY run: if the
+				// ACP driver is absent, the config switch falls back to legacy,
+				// and keying the session as @acp would store a legacy
+				// conversationId under the wrong engine scope.
+				engine: selected === deps.acpDriver ? "acp" : "stream-json",
 			});
 		} else {
 			// Miswired extension: no driver means no engine. Fail the turn visibly