@estebanforge/pi-antigravity-bridge 1.4.8 → 1.4.10

package/extensions/index.ts

@@ -17,10 +17,15 @@
 // ~/.pi/agent/antigravity-bridge/config.json so toggles survive restarts.
 
 import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
 import {
 	type ExtensionAPI,
 	type ExtensionCommandContext,
 	type ExtensionUIContext,
+	createBashToolDefinition,
+	createEditToolDefinition,
+	createWriteToolDefinition,
 	getSettingsListTheme,
 } from "@earendil-works/pi-coding-agent";
 import {
@@ -38,6 +43,7 @@ import {
 } from "../src/models.js";
 import { SessionStore } from "../src/sessions.js";
 import {
+	APPROVAL_PARK_MS,
 	POLL_TOOL_NAME,
 	ToolRoundTrips,
 	WrapperReplay,
@@ -45,7 +51,15 @@ import {
 	formatEscalatedAck,
 	formatPollAnswer,
 } from "../src/provider.js";
-import { AgyDriver } from "../src/driver.js";
+import {
+	createShadowTool,
+	stripMarkerFields,
+	type AnyToolDefinition,
+	type GatePolicy,
+} from "../src/approval-gate.js";
+import { detectPermissionGateExtensions, resolveGateMode } from "../src/approval-detect.js";
+import { hookScriptSource, removeGateHooks, stageGateHooks } from "../src/approval-hook.js";
+import { StreamDriver } from "../src/driver.js";
 import { AcpDriver } from "../src/acp/driver.js";
 import { runAcpAuth } from "../src/acp/auth.js";
 import { setupAuthUrlCapture } from "../src/acp/browser-capture.js";
@@ -55,6 +69,11 @@ import { CONFIG_PATH, loadConfig, logsDir, saveConfig, type AgyMode, type Bridge
 import { createDailyLogger, type DailyLogger } from "../src/daily-log.js";
 import { registerAskAntigravityTool, toolModelsFromRaw } from "../src/ask-tool.js";
 import { startMcpServer, TOKEN_HEADER, type McpServerHandle } from "../src/mcp-server.js";
+import {
+	registerBridgeServer,
+	sweepStaleBridgeServers,
+	unregisterBridgeServer,
+} from "../src/mcp-registration.js";
 import {
 	ACTIVATE_SKILL_TOOL_NAME,
 	activateSkillSchema,
@@ -107,7 +126,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	const engine: Engine = loadConfig().engine;
 	// Engine switching requires a restart, so the catalog-time engine read is
 	// authoritative for input advertising: image attach rides only when turns
-	// will run on the ACP engine (the legacy CLI prompt is text-only).
+	// will run on the ACP engine (the stream-json CLI prompt is text-only).
 	const modelInput: Array<"text" | "image"> = engine === "acp" ? ["text", "image"] : ["text"];
 	const models = entries.map((e) => toPiModel(e, modelInput));
 
@@ -116,6 +135,36 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	// src/daily-log.ts). Fire-and-forget, secrets redacted, old days pruned.
 	// Support flow: "attach the last days' files from that dir".
 	const fileLog = createDailyLogger({ dir: logsDir() });
+	// Warn tier = user-facing: the default file log keeps ONLY errors (zero
+	// routine disk traffic), so a warn that never reaches the UI is lost.
+	// Every warn toasts here instead; AGY_DEBUG=1 restores the full file
+	// trail. Silent exceptions: deliberate aborts (pi already shows
+	// "Operation aborted"), connection exits (the turn's own error block
+	// carries real crashes), and call-tool-fail (same-instant duplicate of
+	// round-trip-fail). No UI (headless): warn text falls back to stderr.
+	const rawFileLog = fileLog.log.bind(fileLog);
+	fileLog.log = (event, data, level) => {
+		rawFileLog(event, data, level);
+		if (level !== "warn") return;
+		if (event.startsWith("abort:") || event === "connection-exited" || event === "call-tool-fail") return;
+		const d = (data ?? {}) as Record<string, unknown>;
+		let text: string;
+		if (event === "round-trip-fail") {
+			text = `Bridge tool call failed: ${String(d.name ?? "tool")} (${String(d.reason ?? "unknown")})`;
+		} else if (event.startsWith("stall:")) {
+			text = "Antigravity stalled with no output; the turn was stopped";
+		} else if (event.startsWith("timeout:")) {
+			text = "Antigravity turn timed out";
+		} else if (event.startsWith("exit:") && event !== "exit:0") {
+			text = "Antigravity process exited unexpectedly";
+		} else if (event === "turn-error") {
+			text = `Antigravity turn issue: ${String(d.reason ?? "unknown")}`;
+		} else {
+			text = `Antigravity warning: ${event}`;
+		}
+		if (activeUi) activeUi.notify(text, "warning");
+		else console.error(`[antigravity-bridge] ${text}`);
+	};
 	fileLog.log(
 		"extension-load",
 		{ engine, models: models.length, fallback: usingFallback, bridge: loadConfig().bridgeTools, askTool: loadConfig().askTool },
@@ -126,6 +175,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	// MCP bridge handle, declared early: the ACP engine reads the bridge port
 	// at session/new / session/load time.
 	let mcpHandle: McpServerHandle | null = null;
+	// Approval-gate hook script (per-pid, token embedded). Written at session
+	// start when the gate is active; removed at session_shutdown.
+	let gateScriptPath: string | null = null;
 	// ACP self-heal runs once per process (session_start re-fires on /reload;
 	// a ready setup is two file stats, so re-running is harmless anyway).
 	let acpSelfHealRan = false;
@@ -154,11 +206,11 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		"session-load-failed-creating-fresh", "connection-exited", "cancel-failed",
 		"unsupported-server-request",
 	]);
-	const legacyDriver = new AgyDriver();
-	// Mirror the legacy driver's lifecycle ring into the daily file log
+	const streamDriver = new StreamDriver();
+	// Mirror the stream driver's lifecycle ring into the daily file log
 	// (spawn/exit/abort/stall/recycle). The ACP driver reaches the same file
 	// through acpLog below.
-	legacyDriver.log = (msg, data) => {
+	streamDriver.log = (msg, data) => {
 		// Level classification mirrors acpLog's failure set: stalls, aborts,
 		// timeouts and nonzero exits are the "what broke" greps (warn);
 		// turn-start is the per-turn skeleton (info); everything else is
@@ -183,12 +235,19 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 				: data;
 		// Failures warn; turn-start + auth-url are the always-on skeleton;
 		// routine per-event lifecycle (spawn, session-load, unparked, ...) is
-		// verbose-only.
-		const level = acpFailures.has(msg)
-			? "warn"
-			: msg === "turn-start" || msg === "auth-url"
-				? "info"
-				: "debug";
+		// verbose-only. Deliberate teardown exits (Esc abort kill, shutdown,
+		// idle recycle) demote to debug: routine, and the warn tier stays the
+		// "what broke" grep.
+		const expectedExit =
+			msg === "connection-exited" &&
+			(data as { expected?: boolean } | undefined)?.expected === true;
+		const level = expectedExit
+			? "debug"
+			: acpFailures.has(msg)
+				? "warn"
+				: msg === "turn-start" || msg === "auth-url"
+					? "info"
+					: "debug";
 		fileLog.log(msg, fileData, level);
 		if (msg === "auth-url") {
 			const { url, port } = (data ?? {}) as { url?: string; port?: number | null };
@@ -209,7 +268,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			return;
 		}
 		if (!acpFailures.has(msg)) return;
-		console.error(`[antigravity-bridge acp] ${msg}${data !== undefined ? " " + JSON.stringify(data) : ""}`);
+		// Console noise is gone: warns toast through the fileLog wrapper (with
+		// a stderr fallback when no UI exists), and raw tails stay in the file
+		// log behind AGY_DEBUG.
 	};
 	const acpDriver = new AcpDriver({
 		// Resolved per connection: the setup flow can install the binary and
@@ -221,7 +282,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 			const handle = mcpHandle;
 			if (!handle) return [];
 			// The bridge 403s any request without the shared-secret header; the
-			// legacy engine carries it via mcp_config.json, ACP via headers[].
+			// stream engine carries it via mcp_config.json, ACP via headers[].
 			return [
 				{
 					name: "pi-bridge",
@@ -233,15 +294,23 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		},
 	});
 	// The active engine is resolved from the latched load-time value.
-	const activeDriver = (): TurnDriver => (engine === "acp" ? acpDriver : legacyDriver);
-	// The provider's stream-json slot gets the LEGACY driver explicitly - never
+	const activeDriver = (): TurnDriver => (engine === "acp" ? acpDriver : streamDriver);
+	// The provider's stream-json slot gets the STREAM driver explicitly - never
 	// activeDriver(), or a load-time acp engine would make deps.driver and
 	// deps.acpDriver the same object and break the engine identity check.
-	const driver = legacyDriver;
+	const driver = streamDriver;
 	// The no-patch pi-tool round-trip store: the MCP bridge parks calls here;
 	// the provider emits them as real pi toolUse turns and completes them from
 	// the next call's toolResult.
-	const roundTrips = new ToolRoundTrips(activeDriver, (s, d) => fileLog.log(s, d, s === "round-trip-fail" ? "warn" : "debug"));
+	const roundTrips = new ToolRoundTrips(
+		activeDriver,
+		(s, d, level) =>
+			fileLog.log(
+				s,
+				d,
+				level ?? (s === "round-trip-fail" ? "warn" : "debug"),
+			),
+	);
 	const replay = new WrapperReplay();
 	// Native re-exec only emits for builtins actually active in the session;
 	// anything else (or an unknown name) falls back to the wrapper card.
@@ -267,7 +336,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		);
 		roundTrips.failAll("antigravity turn ended with an unresolved pi tool call");
 	};
-	legacyDriver.onTurnEnd = onTurnEnd;
+	streamDriver.onTurnEnd = onTurnEnd;
 	acpDriver.onTurnEnd = onTurnEnd;
 	const streamSimple = createStreamSimple({
 		entries,
@@ -518,9 +587,113 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 				isError: !skill,
 			});
 		};
-		const r = await startMcpServer({ listTools, onToolCall: bridgeOnToolCall }, { log: mcpLog });
+		const r = await startMcpServer(
+			{
+				listTools,
+				onToolCall: bridgeOnToolCall,
+				onApproval: (ticket, payload) => roundTrips.onApproval(ticket, payload),
+			},
+			{ log: mcpLog },
+		);
 		if (r.ok && r.handle) {
 			mcpHandle = r.handle;
+			// Stream-json engine registration: the agy CLI discovers MCP servers
+			// from ~/.gemini/config/mcp_config.json (ACP uses session/new
+			// mcpServers instead; verified live 2026-09-07). Per-pid entry,
+			// removed at session_shutdown; stale entries swept at start.
+			sweepStaleBridgeServers();
+			registerBridgeServer({
+				pid: process.pid,
+				port: r.handle.port,
+				token: r.handle.token,
+				tokenHeader: TOKEN_HEADER,
+			});
+			// --- Approval gate (docs/TODO.md 2.5) ------------------------------
+			// agy native tool calls pass through a pi-side approval: a PreToolUse
+			// hook parks in the bridge, the provider emits a shadow toolUse, and
+			// pi's permission extensions gate it like any native call. Off until
+			// enabled (auto = on only when a third-party gate extension exists).
+			{
+				const cfg = loadConfig();
+				const mode = resolveGateMode(cfg.approvals.gateMode, detectPermissionGateExtensions());
+				if (mode === "dedicated") {
+					// The explicit antigravity_approve variant is planned; until it
+					// ships, dedicated stages the same shadow tools. Say so, so the
+					// config value never lies silently.
+					fileLog.log("approval-dedicated-as-shadow", {}, "warn");
+				}
+				if (mode === "off") {
+					// Gate off: remove ONLY this session's group. Other sessions'
+					// groups in a shared workspace are never touched - a gate-off
+					// session must not strip a gate-on session's matchers.
+					const unstaged = removeGateHooks(process.cwd());
+					if (unstaged.wrote) fileLog.log("approval-unstaged", unstaged, "info");
+				} else {
+					// Script: per-pid file; 0600 because the bridge token is
+					// embedded (peer review 2026-09-07).
+					const scriptPath = path.join(logsDir(), `approval-hook-${process.pid}.js`);
+					fs.mkdirSync(path.dirname(scriptPath), { recursive: true, mode: 0o700 });
+					fs.writeFileSync(
+						scriptPath,
+						hookScriptSource({
+							port: r.handle.port,
+							token: r.handle.token,
+							deadlineMs: APPROVAL_PARK_MS,
+						}),
+						{ mode: 0o600 },
+					);
+					gateScriptPath = scriptPath;
+					const staged = stageGateHooks(process.cwd(), {
+						port: r.handle.port,
+						token: r.handle.token,
+						scriptPath,
+						parkBudgetMs: APPROVAL_PARK_MS,
+					});
+					fileLog.log("approval-staged", { mode, script: scriptPath, ...staged }, staged.wrote ? "info" : "debug");
+
+					// Shadow bases: factory twins of pi's own builtins (public API).
+					// pi.getAllTools() is unusable here: it returns ToolInfo, which
+					// strips execute. Marker calls never execute; non-marker calls
+					// delegate to the twins, so behavior matches the standard
+					// builtins (session-level bash-operations overrides are not
+					// inherited; documented in README).
+					const gateCwd = process.cwd();
+					const bases: Record<string, AnyToolDefinition> = {
+						bash: createBashToolDefinition(gateCwd) as unknown as AnyToolDefinition,
+						write: createWriteToolDefinition(gateCwd) as unknown as AnyToolDefinition,
+						edit: createEditToolDefinition(gateCwd) as unknown as AnyToolDefinition,
+					};
+					const askMode = cfg.approvals.mode;
+					const policy: GatePolicy = async ({ tool, params, ctx }) => {
+						if (askMode === "allow") return { allow: true };
+						if (askMode === "deny") {
+							return { allow: false, reason: `blocked by approval gate (mode: deny): ${tool}` };
+						}
+						const extCtx = ctx as { hasUI?: boolean; ui?: Pick<ExtensionUIContext, "confirm"> } | undefined;
+						if (!extCtx?.hasUI || typeof extCtx.ui?.confirm !== "function") {
+							return { allow: false, reason: `approval gate: no UI to approve ${tool} (headless)` };
+						}
+						const what =
+							typeof params.command === "string"
+								? params.command
+								: typeof params.path === "string"
+									? params.path
+									: JSON.stringify(stripMarkerFields(params)).slice(0, 200);
+						const ok = await extCtx.ui.confirm(`agy ${tool}?`, what, { timeout: APPROVAL_PARK_MS });
+						return ok ? { allow: true } : { allow: false, reason: `declined in pi (agy ${tool})` };
+					};
+					const handle = r.handle;
+					for (const [name, base] of Object.entries(bases)) {
+						pi.registerTool(
+							createShadowTool(base, policy, { verifyTicket: (t) => handle.approvals.has(t) }),
+						);
+					}
+					// The park is wired ONLY after the shadows are registered: an
+					// approval toolUse must never dispatch to the REAL builtin and
+					// execute locally.
+					roundTrips.approvalPark = handle.approvals;
+				}
+			}
 		} else {
 			console.error(`[antigravity-bridge] MCP tool bridge disabled: ${r.reason}`);
 		}
@@ -533,8 +706,29 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		mcpHandle = null;
 		await h?.close();
 		roundTrips.failAll("antigravity session shut down");
-		await legacyDriver.close("shutdown");
-		await acpDriver.close("shutdown");
+		// "recycle", NOT "shutdown": pi fires session_shutdown on /new, /resume
+		// and /fork (docs/extensions.md session lifecycle), not only on process
+		// exit. The drivers are process-lifetime singletons; closing them with
+		// "shutdown" latched them permanently and every later turn failed with
+		// "ACP driver is shut down." (regression 2026-09-07). Recycle kills the
+		// connection now; the next turn respawns it. event.reason is
+		// deliberately ignored: recycle is correct even on real process exit
+		// ("quit") - the connection kill is identical and nothing runs after.
+		await streamDriver.close("recycle", "session shutdown");
+		await acpDriver.close("recycle", "session shutdown");
+		unregisterBridgeServer(process.pid);
+		// Approval gate: unstage hooks and remove the per-pid script. Pending
+		// approvals already failed closed via handle close (bridge shutdown deny).
+		const unstaged = removeGateHooks(process.cwd());
+		if (unstaged.wrote) fileLog.log("approval-unstaged", unstaged, "info");
+		if (gateScriptPath) {
+			try {
+				fs.rmSync(gateScriptPath, { force: true });
+			} catch {
+				/* best effort */
+			}
+			gateScriptPath = null;
+		}
 	});
 }
 
@@ -793,7 +987,7 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 					`  sessions:      ${ctx.store.size} bound`,
 					`  models:        ${ctx.entries.length} ${ctx.usingFallback ? "FALLBACK (agy models failed)" : "discovered"}`,
 					`  config:        ${CONFIG_PATH}`,
-					`  logs:          ${logsDir()} (attach recent days' files when reporting issues)`,
+					`  logs:          ${logsDir()} (attach recent days' files when reporting issues; set AGY_DEBUG=1 to capture details)`,
 				];
 				if (snap.engine === "acp" && snap.acp) {
 					lines.push(
@@ -801,6 +995,11 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 						`  acp server:    ${snap.acp.serverVersion ?? "unknown"}${snap.acp.agentTitle ? ` (${snap.acp.agentTitle})` : ""}`,
 						`  acp stats:     prompts=${snap.acp.prompts} created=${snap.acp.sessionsCreated} loaded=${snap.acp.sessionsLoaded} kills=${snap.acp.kills} reconnects=${snap.acp.reconnects} cancel=${snap.acp.cancelSupported === null ? "unprobed" : snap.acp.cancelSupported ? "supported" : "unsupported (kill+reload)"}`,
 					);
+					// Gate B watch: silent while the server offers no token counts; one
+					// line the day it starts (then real usage mapping is worth wiring).
+					if (snap.acp.usageSeen) {
+						lines.push("  acp tokens:    AVAILABLE in server payloads (wire real usage mapping next)");
+					}
 				}
 				if (snap.lifecycle.length > 0) {
 					lines.push("  lifecycle (last 5):");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "Gemini provider for Pi on the Antigravity ACP server (official Google ACP) or the stream-json agy CLI. antigravity/* models in Pi's /model picker, no-patch MCP bridge: agy runs Pi's tools. ToS safe to use.",
   "keywords": [
     "pi-package",

package/src/acp/connection.ts

@@ -24,6 +24,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parseAuthPort, readLastUrl } from "./browser-capture.js";
+import { frameCarriesUsage } from "./events.js";
 import { JsonRpcResponseError, JsonRpcSession } from "./jsonrpc.js";
 
 export interface AcpMcpServer {
@@ -80,6 +81,7 @@ export class AcpConnection {
 	#child: ChildProcess | undefined;
 	#rpc: JsonRpcSession | undefined;
 	#stderrTail = "";
+	#usageSeen = false;
 	#exited = false;
 	#killed = false;
 	#suppressUpdates = false;
@@ -106,6 +108,13 @@ export class AcpConnection {
 		return this.#stderrTail;
 	}
 
+	/** Gate B watch: latched true once any session/update frame carried
+	 *  usage/token fields. /agy doctor surfaces it the day upstream starts
+	 *  sending token counts; silent until then. */
+	get usageSeen(): boolean {
+		return this.#usageSeen;
+	}
+
 	/** While true, session/update notifications are dropped: they are the
 	 *  full-text history replay that precedes a session/load response, never
 	 *  live generation (run 6). */
@@ -299,6 +308,9 @@ export class AcpConnection {
 
 	#onNotification(method: string, params: unknown): void {
 		if (method === "session/update") {
+			// Latched before the suppression gate: history-replay frames are the
+			// server's payloads too, and they are the cheapest signal source.
+			if (!this.#usageSeen && frameCarriesUsage(params)) this.#usageSeen = true;
 			if (this.#suppressUpdates) return; // load replay: history, not live text
 			const p = typeof params === "object" && params !== null ? (params as Record<string, unknown>) : {};
 			const sessionId = typeof p.sessionId === "string" ? p.sessionId : this.#updateSessionId;

package/src/acp/driver.ts

@@ -1,8 +1,8 @@
 // AcpDriver: the ACP turn engine. Implements the same TurnDriver surface as
-// the legacy stream-json driver (see src/driver-types.ts) so provider.ts and
+// the stream-json driver (see src/driver-types.ts) so provider.ts and
 // the G9 round-trip store work unchanged.
 //
-// Engine differences vs legacy, all verified live (docs/ACP-PROTOCOL-REFERENCE.md):
+// Engine differences vs stream-json, all verified live (docs/ACP-PROTOCOL-REFERENCE.md):
 //   - no process recycle on profile drift: one server process, sessions
 //     selected per turn via session/new / session/load
 //   - model/effort via session/set_config_option (configId "model", FULL slug
@@ -110,7 +110,6 @@ export class AcpDriver implements TurnDriver {
 	#generation = 0;
 	#active: ActiveTurn | undefined;
 	#queueTail: Promise<void> = Promise.resolve();
-	#shutdown = false;
 	#lifecycle: string[] = [];
 	#onTurnEnd: ((outcome: TurnOutcome) => void) | undefined;
 	#stats = {
@@ -168,7 +167,7 @@ export class AcpDriver implements TurnDriver {
 	}
 
 	/** Turns are serialized; a parked turn stays open and the continuation
-	 *  path uses reentry() (same contract as the legacy driver). */
+	 *  path uses reentry() (same contract as the stream-json driver). */
 	run(request: DriverTurnRequest): Promise<TurnHandle> {
 		let release!: () => void;
 		const prev = this.#queueTail;
@@ -190,7 +189,10 @@ export class AcpDriver implements TurnDriver {
 	}
 
 	#runExclusive(request: DriverTurnRequest): Promise<TurnHandle> {
-		if (this.#shutdown) return Promise.reject(new Error("ACP driver is shut down."));
+		// No shutdown latch here: pi fires session_shutdown on /new, /resume and
+		// /fork (not only process exit), so a closed driver must respawn on the
+		// next turn instead of rejecting forever. Regression 2026-09-07:
+		// /compact after a model switch failed with "ACP driver is shut down."
 		if (request.signal?.aborted) return Promise.reject(new Error("aborted before start"));
 
 		const turn = this.#createTurn(request);
@@ -218,7 +220,7 @@ export class AcpDriver implements TurnDriver {
 		}
 
 		// Execute asynchronously: the handle returns as soon as the prompt is
-		// dispatched, and activities stream through next() (legacy contract).
+		// dispatched, and activities stream through next() (stream-json contract).
 		void this.#executeTurn(turn).catch((err: unknown) => {
 			this.#failTurn(turn, `ACP turn failed: ${describe(err)}`);
 		});
@@ -409,7 +411,12 @@ export class AcpDriver implements TurnDriver {
 		const turn = this.#active;
 		this.#conn = undefined;
 		this.#state = "dead";
-		this.#log("connection-exited", { tail: info.stderrTail.slice(-200) });
+		// Teardown exits (abort kill, shutdown, idle recycle) are deliberate:
+		// their stderr tail must never reach the UI. Only a live turn dying
+		// mid-flight is user-reportable, and it surfaces as a normal turn
+		// error, not as raw console noise.
+		const turnActive = Boolean(turn && !turn.closed && !turn.aborted && !turn.sawResult);
+		this.#log("connection-exited", { expected: !turnActive, tail: info.stderrTail.slice(-200) });
 		if (!turn || turn.closed) return;
 		if (turn.aborted || turn.sawResult) {
 			this.#settle(turn, {
@@ -421,7 +428,7 @@ export class AcpDriver implements TurnDriver {
 			});
 			return;
 		}
-		this.#failTurn(turn, info.stderrTail.trim() || "ACP server exited mid-turn");
+		this.#failTurn(turn, "Antigravity session exited unexpectedly; it restarts on the next turn");
 	}
 
 	#ensureConnection(request: DriverTurnRequest): Promise<AcpConnection> {
@@ -674,7 +681,6 @@ export class AcpDriver implements TurnDriver {
 	// --- TurnDriver surface ----------------------------------------------------
 
 	async close(reason: "recycle" | "shutdown", cause?: string): Promise<void> {
-		if (reason === "shutdown") this.#shutdown = true;
 		this.#log(`close:${reason}${cause ? `:${cause}` : ""}`);
 		const turn = this.#active;
 		if (turn && !turn.closed) {
@@ -682,7 +688,7 @@ export class AcpDriver implements TurnDriver {
 				conversationId: turn.sessionId,
 				status: "ERROR",
 				response: turn.response.text,
-				error: `ACP driver ${reason}ed mid-turn${cause ? ` (${cause})` : ""}`,
+				error: `ACP driver ${reason === "recycle" ? "recycled" : "shut down"} mid-turn${cause ? ` (${cause})` : ""}`,
 				finished: true,
 				aborted: false,
 			});
@@ -721,6 +727,7 @@ export class AcpDriver implements TurnDriver {
 				reconnects: Math.max(0, this.#stats.spawns - 1),
 				agentName: this.#agentInfo?.name,
 				agentTitle: this.#agentInfo?.title,
+				usageSeen: this.#conn?.usageSeen ?? false,
 			},
 		};
 	}

package/src/acp/events.ts

@@ -248,3 +248,20 @@ export class TextAccumulator {
 		return this.#acc;
 	}
 }
+
+const USAGE_KEY = /usage|tokens?/i;
+
+/** Gate B watch: true when a server payload carries usage/token fields.
+ *  Key-name based so future shapes (usage blocks, _meta.tokenCount, top-level
+ *  token totals) all trip it. String values are exempt so auth-style "token"
+ *  args inside tool-call frames cannot false-positive the latch; depth-capped
+ *  so the walk stays cheap on every frame until it latches. */
+export function frameCarriesUsage(value: unknown, depth = 0): boolean {
+	if (depth > 8 || typeof value !== "object" || value === null) return false;
+	if (Array.isArray(value)) return value.some((v) => frameCarriesUsage(v, depth + 1));
+	for (const [key, v] of Object.entries(value)) {
+		if (USAGE_KEY.test(key) && (typeof v === "number" || typeof v === "object")) return true;
+		if (frameCarriesUsage(v, depth + 1)) return true;
+	}
+	return false;
+}