@estebanforge/pi-antigravity-bridge 1.4.9 → 1.5.0

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,16 +51,30 @@ 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";
 import { ensureAcpReady, inspectAcpSetup } from "../src/acp/setup.js";
 import type { TurnDriver, TurnOutcome } from "../src/driver-types.js";
 import { CONFIG_PATH, loadConfig, logsDir, saveConfig, type AgyMode, type BridgeTools, type Engine, type ThinkingTier } from "../src/config.js";
+import { agyMissingMessage, isAgyInstalled, savedEngineMessage, showEnginePicker, shouldOfferEnginePicker } from "../src/engine-picker.js";
 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 +127,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));
 
@@ -156,9 +176,14 @@ 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;
+	// Warn-once-per-process flag for the missing-agy-CLI toast (stream-json).
+	let agyMissingWarned = false;
 	// OAuth URL capture: the server hands the login URL only to the
 	// browser-open call (nothing on stdio), so a BROWSER wrapper records it
 	// and the driver logs it as "auth-url". Local users keep the automatic
@@ -184,11 +209,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
@@ -254,13 +279,17 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		// Resolved per connection: the setup flow can install the binary and
 		// update acp.bin mid-session; the next turn picks it up (no restart).
 		bin: () => loadConfig().acp.bin,
+		// Resolved per turn: /agy and AGY_USAGE_ESTIMATE changes apply without
+		// a restart. Without this the driver defaults to "estimate" and the
+		// config knob (incl. "off") is dead.
+		usageEstimate: () => loadConfig().acp.usageEstimate,
 		...(authCapture ? { extraEnv: authCapture.browserEnv, authUrlFile: authCapture.file } : {}),
 		log: acpLog,
 		mcpServers: () => {
 			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",
@@ -272,15 +301,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.
@@ -306,7 +343,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,
@@ -350,6 +387,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		acpLog,
 		fileLog,
 		authCapture: authCapture ?? null,
+		runAcpPickSetup,
 	});
 
 	// AskAntigravity tool: one-shot delegation to agy (ported from
@@ -382,12 +420,115 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		},
 	});
 
+	/** ACP pick follow-through (first-run wizard): the same self-service
+	 *  setup the /agy engine acp command runs, but immediately - the 1.5 GB
+	 *  download starts while the toast is still on screen, progress rides the
+	 *  footer status, and the Google sign-in opens when the install lands.
+	 *  Restart still applies the engine (drivers wire at load); this only
+	 *  removes the wait. Fire-and-forget: the caller already toasted the
+	 *  promise, failures land in the daily log + a warning toast. */
+	// eslint-disable-next-line @typescript-eslint/no-inner-declarations -- hoisted: registerAgyCommand below injects it
+	async function runAcpPickSetup(ctx: { ui: ExtensionUIContext }): Promise<void> {
+		acpSelfHealRan = true;
+		let lastPhase = "";
+		ctx.ui.setStatus("agy-acp", "downloading ACP server…");
+		try {
+			const status = await ensureAcpReady({
+				configBin: loadConfig().acp.bin,
+				onProgress: (m) => {
+					// Dual surface: the status bar carries the live percent (cleared
+					// on completion, zero footprint); the chat window gets phase
+					// milestones only (download start, unpacking, installed) - same
+					// line-in-chat feel as other extensions' notify() notices. The
+					// percent variant updates every chunk and would spam the chat.
+					ctx.ui.setStatus("agy-acp", m);
+					if (m !== lastPhase && !/\d+%/.test(m)) {
+						ctx.ui.notify(m, "info");
+						lastPhase = m;
+					}
+				},
+			});
+			ctx.ui.setStatus("agy-acp", undefined);
+			fileLog.log(
+				"acp-setup",
+				status.ok
+					? { ok: true, binarySource: status.binarySource, needsLogin: status.needsLogin }
+					: { ok: false, error: status.error },
+				status.ok ? "info" : "warn",
+			);
+			if (!status.ok) {
+				ctx.ui.notify(`ACP auto-setup failed (${status.error}).\n${status.manual}`, "warning");
+				return;
+			}
+			// Spread, not a bare acp patch: a bare {bin} patch would drop
+			// sibling keys (usageEstimate) from the file.
+			saveConfig({ acp: { ...loadConfig().acp, bin: status.bin } });
+			if (!status.needsLogin) {
+				ctx.ui.notify(`ACP server ready (auth: ${status.auth}). Restart applies the engine.`, "info");
+				return;
+			}
+			ctx.ui.notify(
+				"ACP server ready. Signing in: the Google sign-in opens in your browser and completes when you finish it.",
+				"info",
+			);
+			const r = await runAcpAuth({
+				bin: status.bin,
+				...(authCapture ? { extraEnv: authCapture.browserEnv, authUrlFile: authCapture.file } : {}),
+				log: acpLog,
+			});
+			fileLog.log("acp-auth", r.ok ? { ok: true } : { ok: false, error: r.error }, r.ok ? "info" : "warn");
+			if (r.ok) ctx.ui.notify("Signed in. The ACP engine is ready; restart applies it.", "info");
+			else ctx.ui.notify(`ACP sign-in failed (${r.error}).\nRun /agy auth to retry; /agy auth-manual has manual steps.`, "warning");
+		} catch (err) {
+			ctx.ui.setStatus("agy-acp", undefined);
+			fileLog.log("acp-setup", { error: String(err) }, "warn");
+			ctx.ui.notify(`ACP setup failed (${String(err)}). /agy auth retries; /agy doctor inspects.`, "warning");
+		}
+	}
+
 	// MCP tool bridge: expose pi's tools to agy over localhost Streamable HTTP.
 	// Calls park in the provider's round-trip store and complete through pi's
 	// normal toolUse loop (native cards, permissions, hooks) - no patch, no
 	// privileged API. Started on session_start, torn down on session_shutdown.
-	pi.on("session_start", async (_event, ctx) => {
+	pi.on("session_start", async (event, ctx) => {
 		if (ctx.hasUI) activeUi = ctx.ui;
+		// First-run engine picker: ask once, on the first interactive start,
+		// which turn engine to use. Skipped headless (ctx.mode !== "tui"),
+		// when AGY_ENGINE is set, or once any config file exists (any save -
+		// even of an unrelated knob - means the user has been here before).
+		// esc = decide later: nothing is written, the picker reappears next
+		// start. Like /agy engine, the choice applies on the next start
+		// (drivers wire at load). The await intentionally runs before the
+		// bridge startup below: on a genuine first run the modal blocks input
+		// anyway, so the delay is invisible.
+		if (event.reason === "startup" && ctx.mode === "tui" && shouldOfferEnginePicker(CONFIG_PATH)) {
+			// Best-effort, like the legacy-patch notice below: a picker failure
+			// (mid-prompt TUI teardown, resize races) must never take down the
+			// rest of session_start - the MCP bridge startup included. The
+			// default engine keeps working untouched.
+			try {
+				const picked = await showEnginePicker(ctx.ui);
+				if (picked) {
+					saveConfig({ engine: picked });
+					ctx.ui.notify(savedEngineMessage(picked), "info");
+					if (picked === "acp") void runAcpPickSetup(ctx);
+				}
+			} catch (err) {
+				fileLog.log("engine-picker", { error: String(err) }, "warn");
+				console.error(`[antigravity-bridge] engine picker failed: ${String(err)}`);
+			}
+		}
+		// agy presence check (stream-json engine): the CLI is the whole engine,
+		// so a missing binary means every Antigravity turn would fail. Warn on
+		// every process start until it is installed (per-process flag so /new,
+		// /resume and /reload re-fires do not nag mid-session). Runs after the
+		// picker above, so a first-run stream-json pick warns immediately.
+		if (engine === "stream-json" && !agyMissingWarned && !isAgyInstalled(binary)) {
+			agyMissingWarned = true;
+			const msg = agyMissingMessage();
+			if (ctx.hasUI) ctx.ui.notify(msg, "warning");
+			else console.error(`[antigravity-bridge] ${msg}`);
+		}
 		// Legacy cleanup: users who ran the old consent-gated patcher still
 		// carry pi.invokeTool in their installed pi. Inert, but tell them once
 		// and offer /agy patch-cleanup. Never auto-edits the install.
@@ -421,7 +562,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 				);
 				if (status.ok) {
 					if (status.binarySource === "installed" || status.binarySource === "existing") {
-						saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+						saveConfig({ acp: { ...loadConfig().acp, bin: status.bin } });
 					}
 					if (status.needsLogin) {
 						const msg = acpLoginPending();
@@ -557,9 +698,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}`);
 		}
@@ -572,8 +817,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;
+		}
 	});
 }
 
@@ -600,6 +866,9 @@ interface AgyCommandCtx {
 	acpLog: (msg: string, data?: unknown) => void;
 	/** Daily file logger (src/daily-log.ts); command + doctor surfacing. */
 	fileLog: DailyLogger;
+	/** Wizard-pick follow-through (download now + chained sign-in); reused
+	 *  by /agy engine's no-args modal so both entry points behave alike. */
+	runAcpPickSetup: (cmdCtx: { ui: ExtensionUIContext }) => Promise<void>;
 	/** BROWSER-capture handles; null when unavailable (Windows, unwritable
 	 *  data dir). /agy auth passes them to the sign-in process. */
 	authCapture: { browserEnv: Record<string, string>; file: string } | null;
@@ -711,7 +980,7 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 						ui?.notify(`ACP auto-setup failed (${status.error}).\n${status.manual}`, "warning");
 						return;
 					}
-					saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+					saveConfig({ acp: { ...loadConfig().acp, bin: status.bin } });
 					if (status.needsLogin) {
 						ui?.notify(
 							`ACP engine set. ${acpLoginPending()}`,
@@ -720,6 +989,28 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 					} else {
 						ui?.notify(`ACP engine ready (auth: ${status.auth}). Takes effect on the next pi start (or /reload).`, "info");
 					}
+				} else if (!val && mode === "tui" && ui) {
+					// Same modal as the first-run wizard: switching engines deserves
+					// the explanations, not a bare usage line. Semantics match the
+					// direct path above: plan blocks acp, an acp pick chains setup
+					// + sign-in immediately, restart applies the switch.
+					const current = loadConfig().engine;
+					const picked = await showEnginePicker(ui);
+					if (picked === null) {
+						ui.notify(`engine unchanged: ${current}.`, "info");
+						return;
+					}
+					if (picked === current) {
+						ui.notify(`engine is already ${current}. Restart applies it if set this session.`, "info");
+						return;
+					}
+					if (picked === "acp" && loadConfig().mode === "plan") {
+						ui.notify("mode is plan; the ACP engine has no plan mode. /agy mode accept-edits first.", "warning");
+						return;
+					}
+					saveConfig({ engine: picked });
+					ui.notify(savedEngineMessage(picked), "info");
+					if (picked === "acp") void ctx.runAcpPickSetup({ ui });
 				} else {
 					ui?.notify(`current engine: ${loadConfig().engine}\nusage: /agy engine stream-json|acp`, "info");
 				}
@@ -746,7 +1037,7 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 					ui?.notify(`ACP auto-setup failed (${status.error}).\n${status.manual}`, "warning");
 					return;
 				}
-				saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+				saveConfig({ acp: { ...loadConfig().acp, bin: status.bin } });
 				if (!status.needsLogin) {
 					ui?.notify(`Already signed in (auth: ${status.auth}). Nothing to do.`, "info");
 					return;
@@ -774,7 +1065,9 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				if (rest.length > 0) {
 					// Only the keyword compares case-insensitively; the path keeps its case.
 					const bin = rest.toLowerCase() === "auto" ? "" : rest.replace(/^~(?=\/|$)/, os.homedir());
-					saveConfig({ acp: { bin, permissions: loadConfig().acp.permissions } });
+					// Spread, not a bare acp patch: a bare {bin, permissions} object
+					// would drop sibling keys (usageEstimate) from the file.
+					saveConfig({ acp: { ...loadConfig().acp, bin } });
 					ui?.notify(
 						bin
 							? `acp.bin set to ${bin}. The next ACP turn (re)connects with it.`
@@ -844,6 +1137,8 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 					// 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)");
+					} else if (config.acp.usageEstimate !== "off") {
+						lines.push(`  acp tokens:    ESTIMATED client-side (mode: ${config.acp.usageEstimate}; auto-off once the server sends real usage)`);
 					}
 				}
 				if (snap.lifecycle.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.4.9",
+  "version": "1.5.0",
   "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",