@estebanforge/pi-antigravity-bridge 1.4.1 → 1.4.3

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.4.3] - 2026-09-04
+
+### Added
+
+- AskAntigravity tool toggle: `/agy ask on|off`, an "AskAntigravity tool" row in the bare-`/agy` picker, and the `askTool` config key (env `AGY_ASK_TOOL`). Default on; `off` skips registering the AskAntigravity one-shot delegation tool entirely, for users who want only the provider and its models and no delegation tool in the model's window context. When the separate pi-ask-antigravity package is also installed, `off` means no delegation tool from either package (no fallback). Takes effect on the next pi start (or /reload); `/agy status` shows the state.
+
+### Changed
+### Changed
+
+- The bare-`/agy` settings picker gains a Turn engine row (`stream-json`/`acp`). Saving `acp` persists the switch, then runs the same self-service setup as `/agy engine acp` (binary install + auth bootstrap, `acp.bin` updated). The plan+acp RC01 guard now evaluates the effective engine AND mode after the save, so a config already in `plan` plus a fresh `acp` pick is refused instead of persisting an invalid combination (peer-review find).
+- "Tool default model/thinking" renamed to "AskAntigravity model/thinking" across the picker, `/agy status`, and toasts; descriptions and README now state the values are fallbacks that callers may override per call.
+- All ACP login-pending messages share one wording that names the antigravity-acp server and its place in Google's Antigravity suite (agy desktop, agy editor, agy cli, agy acp), and clarifies the login: same Google account as the agy CLI, separate login with its own token file.
+
+## [1.4.2] - 2026-09-04
+
+### Changed
+
+- `bridgeTools` now defaults to `all` (every registered non-builtin pi tool) instead of `mcp`. The `mcp` surface filters to pi-mcp-adapter tools and serves an empty catalog on installs without that adapter, which left the bridge registered but tool-less from the model's point of view. `none` still opts out entirely; explicit `"bridgeTools": "mcp"` in an existing config keeps pinning the narrow surface.
+- Skill discovery now mirrors pi's directory-based scan (docs/skills.md): global `~/.pi/agent/skills` AND `~/.agents/skills`, project `.pi/skills` plus `.agents/skills` in cwd and ancestors up to the git root (project dirs only when pi has trusted the project, same gate pi applies), recursive SKILL.md discovery with grouping folders, per-style root/`.md` rules, hidden entries skipped, and description-less skills dropped. Pi's other skill sources (`skills` settings array, `package.json`, `--skill`) are not mirrored. Previously only one flat level of two directories was scanned, and `~/.agents/skills` (where pi actually reads most skills) was missing entirely, so `activate_skill` never appeared.
+- `/agy` now exposes the full runtime config surface: new `/agy bridge all|mcp|none` (which pi tools the MCP bridge hands to agy) and `/agy acp-bin <path|auto>` (target a specific ACP server binary; applies on the next ACP turn), plus Bridge tools, Context digest, and System prompt rows in the bare `/agy` settings picker. Usage strings and `/agy status` list every knob.
+
 ## [1.4.1] - 2026-09-04
 
 ### Added

package/README.md

@@ -104,27 +104,33 @@ If `agy models` fails at load (binary missing, auth not done, network stall), a
 
 | Key | Values | Default |
 | --- | --- | --- |
-| `bridgeTools` | `none` (bridge off), `mcp` (pi-mcp-adapter tools), `all` (every non-builtin tool, incl. other `Ask*` delegations) | `mcp` |
+| `askTool` | `on` (register the AskAntigravity delegation tool), `off` (no delegation tool; provider and models only) | `on` |
+| `bridgeTools` | `none` (bridge off), `all` (every non-builtin tool, incl. other `Ask*` delegations), `mcp` (pi-mcp-adapter tools + skills bridge only) | `all` |
 | `digest` | `off` (stable prompts; agy's prompt cache hits) or `on` (inject a delta of pi-side context - compaction summaries, other-provider turns - into each agy prompt; the delta changes every turn, so agy re-bills the full context). Enable for mixed-provider sessions where agy must see pi-side context | `off` |
 | `systemPrompt` | `on` (prepend pi's system prompt - operating instructions plus the global agent-dir `AGENTS.md` and ancestor `AGENTS.md`/`CLAUDE.md` - to the first prompt of each new agy conversation) or `off` (agy-native behavior) | `on` |
 
-Env overrides: `AGY_BRIDGE_TOOLS`, `AGY_DIGEST`, `AGY_SYSTEM_PROMPT`. Env wins over the file, so while `AGY_DIGEST` or `AGY_SYSTEM_PROMPT` is set, the matching `/agy digest` or `/agy system-prompt` toggle persists a value that never takes effect.
+Env overrides: `AGY_BRIDGE_TOOLS`, `AGY_ASK_TOOL`, `AGY_DIGEST`, `AGY_SYSTEM_PROMPT`. Env wins over the file, so while `AGY_DIGEST` or `AGY_SYSTEM_PROMPT` is set, the matching `/agy digest` or `/agy system-prompt` toggle persists a value that never takes effect.
+
+The `activate_skill` catalog mirrors pi's directory-based skill discovery: the two global dirs plus project dirs, the latter only when pi has trusted the project (same gate pi itself applies). Pi's other skill sources - the `skills` settings array, `package.json` entries, and `--skill` CLI paths - are not mirrored and won't appear in the catalog.
 
 ### The /agy command
 
 `/agy` configures the provider at runtime. Settings persist to `~/.pi/agent/antigravity-bridge/config.json` and take effect on the next turn.
 
 ```
-/agy                      status, or open the mode/permissions/model/thinking picker (TUI)
-/agy status               print current mode, permissions, model + session counts
+/agy                      status, or open the full settings picker (TUI)
+/agy status               print current settings + session counts
 /agy doctor               bridge state, driver counters, bridge port, last lifecycle events
 /agy mode plan            review-only: agy plans but writes nothing
 /agy mode accept-edits    agy applies edits directly (default)
 /agy permissions on|off   auto-approve / prompt for tool calls (see warning)
-/agy model flash|pro|gemini   default model alias for the AskAntigravity tool
-/agy thinking low|medium|high default thinking tier for the AskAntigravity tool
+/agy ask on|off           register the AskAntigravity delegation tool (default on; off keeps only the provider and models, even with pi-ask-antigravity installed)
+/agy model flash|pro|gemini   fallback model for the AskAntigravity tool; callers may override per call
+/agy thinking low|medium|high fallback thinking tier for the AskAntigravity tool; callers may override per call
 /agy digest on|off        inject pi-side context into agy prompts (default off; see table above)
 /agy system-prompt on|off send pi's system prompt + AGENTS.md to new agy conversations (default on)
+/agy bridge all|mcp|none  which pi tools the MCP bridge exposes to agy (default all; none = bridge off)
+/agy acp-bin <path|auto>  point the ACP engine at a specific server binary (auto = setup installs, or AGY_ACP_BIN; applies on the next ACP turn)
 /agy engine acp|stream-json   switch the turn engine (restart to apply; default stream-json; acp runs self-service setup: binary install + auth bootstrap)
 /agy acp-auth                 manual ACP credential setup (fallback; auto-setup normally covers this; default login = your Antigravity subscription, same account as the agy CLI)
 /agy patch-cleanup        restore the original pi files if an older version patched them

package/extensions/index.ts

@@ -11,10 +11,12 @@
 //   ("[agy tool: editing foo.ts]") for visibility, but the edits already landed
 //   on disk and pi's inline diff review does not engage.
 //
-// /agy command: status, mode picker (plan / accept-edits),
-// and session clear. Config persists to ~/.pi/agent/antigravity-bridge/
-// config.json so toggles survive restarts.
+// /agy command: full runtime config surface (engine, mode, permissions,
+// bridge tools, model, thinking, digest, system prompt, acp binary) plus
+// doctor, auth, patch-cleanup, and session clear. Config persists to
+// ~/.pi/agent/antigravity-bridge/config.json so toggles survive restarts.
 
+import os from "node:os";
 import {
 	type ExtensionAPI,
 	type ExtensionCommandContext,
@@ -207,8 +209,13 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 	// AskAntigravity tool: one-shot delegation to agy (ported from
 	// pi-ask-antigravity). When both extensions are installed, the bridge wins
 	// and pi-ask-antigravity registers nothing (its load-time defer guard
-	// detects this package via import.meta.resolve).
-	await registerAskAntigravityTool(pi, toolModels);
+	// detects this package via import.meta.resolve). Opt-out: askTool=false
+	// (config file, AGY_ASK_TOOL, /agy ask, or the picker) skips registration
+	// entirely - users who want only the provider keep a clean tool list.
+	// Note: the active flag below is set regardless of askTool, so
+	// pi-ask-antigravity keeps deferring even then: off means NO delegation
+	// tool from either package, not a fallback to pi-ask-antigravity.
+	if (loadConfig().askTool) await registerAskAntigravityTool(pi, toolModels);
 
 	// Display-only wrapper tool: the provider emits mutating agy steps as
 	// toolCalls against it (never re-executed - execute() replays the output
@@ -263,8 +270,7 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 						saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
 					}
 					if (status.needsLogin) {
-						const msg =
-							"ACP: one-time Google login pending. Your next antigravity message opens the browser; sign in with your Antigravity subscription account (the same login as the agy CLI). Tokens stay on your machine.";
+						const msg = acpLoginPending("Your next antigravity message opens the browser;");
 						if (ctx.hasUI) ctx.ui.notify(msg, "info");
 						else console.error(`[antigravity-bridge] ${msg}`);
 					}
@@ -304,7 +310,9 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 		if (bridgeMode === "none") return; // user opted out
 		if (mcpHandle) return; // already running (reload re-fires session_start)
 		const SKIP = new Set(["AskAntigravity"]);
-		const skills: SkillLite[] = scanSkills(process.cwd());
+		// pi loads project skill locations only after the project is trusted;
+		// mirror that gate. Global skill dirs are always scanned.
+		const skills: SkillLite[] = scanSkills(ctx.isProjectTrusted() ? process.cwd() : undefined);
 		const getAll = (pi as unknown as {
 			getAllTools: () => Array<{ name: string; description?: string; parameters?: object; sourceInfo?: { source?: string } }>;
 		}).getAllTools.bind(pi);
@@ -375,6 +383,14 @@ export default async function (pi: ExtensionAPI): Promise<void> {
 
 // --- /agy command -----------------------------------------------------------
 
+/** Shared body for every ACP-login-pending moment (session_start self-heal,
+ *  /agy engine acp, picker): names the component so users know WHAT they are
+ *  logging into, and that it is the same Google account as the agy CLI with
+ *  its own token file. `browserTrigger` says when the browser opens. */
+function acpLoginPending(browserTrigger: string): string {
+	return `One-time Google login pending for the antigravity-acp server, Google's own ACP binary and a separate component of the Antigravity suite (agy desktop, agy editor, agy cli, agy acp). ${browserTrigger} Sign in with your Antigravity subscription account: the same Google account as your agy CLI login, but its own login and token file. One-time; tokens stay on your machine and this extension never sees them.`;
+}
+
 interface AgyCommandCtx {
 	entries: AgyModelEntry[];
 	store: SessionStore;
@@ -387,31 +403,40 @@ interface AgyCommandCtx {
 }
 
 interface PendingConfig {
+	engine?: Engine;
 	mode?: AgyMode;
 	skipPermissions?: boolean;
 	defaultModel?: string;
 	defaultThinking?: ThinkingTier;
+	askTool?: boolean;
+	bridgeTools?: BridgeTools;
+	digest?: boolean;
+	systemPrompt?: boolean;
 }
 
 function statusText(ctx: AgyCommandCtx): string {
 	const config = loadConfig();
 	const source = ctx.usingFallback ? "fallback (agy models failed)" : "discovered";
 	const perm = config.skipPermissions ? "auto-approved (DANGEROUS)" : "prompt (hangs in -p)";
+	// padEnd keyed to the longest label ("AskAntigravity thinking:") so the
+	// value column stays aligned as labels grow.
+	const row = (label: string, value: string) => `  ${label.padEnd(24)} ${value}`;
 	return [
 		"Antigravity bridge",
-		`  engine:        ${config.engine}${config.engine === "acp" ? " (official server, opt-in)" : ""}`,
-		`  models:        ${ctx.entries.length} ${source}`,
-		`  mode:          ${config.mode}`,
-		`  permissions:   ${perm}`,
-		`  tool model:    ${config.defaultModel}`,
-		`  tool thinking: ${config.defaultThinking}`,
-		`  sessions:      ${ctx.store.size} bound`,
-		`  config:        ${CONFIG_PATH}`,
-		`  bridge tools:  ${config.bridgeTools}`,
-		`  digest:        ${config.digest ? "on" : "off"}`,
-		`  system prompt: ${config.systemPrompt ? "on" : "off"}`,
+		row("engine:", `${config.engine}${config.engine === "acp" ? " (official server, opt-in)" : ""}`),
+		row("models:", `${ctx.entries.length} ${source}`),
+		row("mode:", config.mode),
+		row("permissions:", perm),
+		row("AskAntigravity tool:", config.askTool ? "on" : "off"),
+		row("AskAntigravity model:", config.defaultModel),
+		row("AskAntigravity thinking:", config.defaultThinking),
+		row("sessions:", `${ctx.store.size} bound`),
+		row("config:", CONFIG_PATH),
+		row("bridge tools:", config.bridgeTools),
+		row("digest:", config.digest ? "on" : "off"),
+		row("system prompt:", config.systemPrompt ? "on" : "off"),
 		"",
-		"Subcommands: /agy engine stream-json|acp, /agy mode plan|accept-edits, /agy permissions on|off, /agy model flash|pro|gemini, /agy thinking low|medium|high, /agy digest on|off, /agy system-prompt on|off, /agy acp-auth, /agy patch-cleanup, /agy clear",
+		"Subcommands: /agy engine stream-json|acp, /agy mode plan|accept-edits, /agy permissions on|off, /agy ask on|off, /agy model <alias>, /agy thinking low|medium|high, /agy bridge all|mcp|none, /agy digest on|off, /agy system-prompt on|off, /agy acp-bin <path|auto>, /agy acp-auth, /agy patch-cleanup, /agy clear",
 	].join("\n");
 }
 
@@ -419,7 +444,7 @@ function statusText(ctx: AgyCommandCtx): string {
 function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 	pi.registerCommand("agy", {
 		description:
-			"Antigravity provider: status, doctor, engine picker, mode picker, clear sessions. Usage: /agy [status|doctor|engine stream-json|acp|mode [plan|accept-edits]|permissions on|off|digest on|off|system-prompt on|off|acp-auth|patch-cleanup|clear]",
+			"Antigravity provider: status, doctor, settings picker, clear sessions. Usage: /agy [status|doctor|engine stream-json|acp|mode plan|accept-edits|permissions on|off|ask on|off|model <alias>|thinking low|medium|high|bridge all|mcp|none|digest on|off|system-prompt on|off|acp-bin <path|auto>|acp-auth|patch-cleanup|clear]",
 		handler: async (args, cmdCtx: ExtensionCommandContext) => {
 			const ui = cmdCtx.ui;
 			const mode = cmdCtx.mode;
@@ -478,7 +503,7 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 					saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
 					ui?.notify(
 						status.needsLogin
-							? "ACP engine ready. Your first ACP message opens the Google login in your browser: sign in with the account of your Antigravity subscription (the same login as the Antigravity CLI, agy). One-time; tokens stay on your machine and this extension never sees them. Takes effect on the next pi start (or /reload)."
+							? `ACP engine ready. ${acpLoginPending("Your first ACP message (after the next pi start or /reload) opens the browser;")}`
 							: `ACP engine ready (auth: ${status.auth}). Takes effect on the next pi start (or /reload).`,
 						"info",
 					);
@@ -487,6 +512,24 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				}
 				return;
 			}
+			if (sub === "acp-bin") {
+				const rest = (args ?? "").trim().split(/\s+/).slice(1).join(" ");
+				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 } });
+					ui?.notify(
+						bin
+							? `acp.bin set to ${bin}. The next ACP turn (re)connects with it.`
+							: "acp.bin cleared. Auto-setup (or AGY_ACP_BIN) picks the binary on the next ACP turn.",
+						"info",
+					);
+				} else {
+					const cur = loadConfig().acp.bin;
+					ui?.notify(`acp.bin: ${cur || "(auto: setup installs, or AGY_ACP_BIN)"}\nusage: /agy acp-bin <path|auto>`, "info");
+				}
+				return;
+			}
 			if (sub === "acp-auth") {
 				ui?.notify(
 					[
@@ -575,12 +618,40 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 				}
 				return;
 			}
+			if (sub === "bridge") {
+				if (val === "all" || val === "mcp" || val === "none") {
+					const next = saveConfig({ bridgeTools: val });
+					ui?.notify(
+						next.bridgeTools === "none"
+							? "bridge off. The MCP tool bridge will not start on the next pi start (or /reload)."
+							: `bridge tools set to ${next.bridgeTools}. The catalog rebuilds on the next pi start (or /reload).`,
+						"info",
+					);
+				} else {
+					ui?.notify(`bridge: ${loadConfig().bridgeTools}\nusage: /agy bridge all|mcp|none\n  all: every non-builtin pi tool (default). mcp: pi-mcp-adapter tools + skills only. none: bridge off.`, "info");
+				}
+				return;
+			}
 			if (sub === "model") {
 				if (val && val.length > 0) {
 					const next = saveConfig({ defaultModel: val });
-					ui?.notify(`tool default model set to ${next.defaultModel}`, "info");
+					ui?.notify(`AskAntigravity default model set to ${next.defaultModel}`, "info");
+				} else {
+					ui?.notify(`AskAntigravity model: ${loadConfig().defaultModel} (fallback; callers may override per call)\nusage: /agy model flash|pro|gemini|<exact>`, "info");
+				}
+				return;
+			}
+			if (sub === "ask") {
+				if (val === "on" || val === "off") {
+					const next = saveConfig({ askTool: val === "on" });
+					ui?.notify(
+						next.askTool
+							? "AskAntigravity tool on. Registered on the next pi start (or /reload)."
+							: "AskAntigravity tool off. It is removed from the model's tool list on the next pi start (or /reload). Provider and models stay.",
+						"info",
+					);
 				} else {
-					ui?.notify(`tool model: ${loadConfig().defaultModel}\nusage: /agy model flash|pro|gemini|<exact>`, "info");
+					ui?.notify(`AskAntigravity tool: ${loadConfig().askTool ? "on" : "off"}\nusage: /agy ask on|off`, "info");
 				}
 				return;
 			}
@@ -616,9 +687,9 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 			if (sub === "thinking") {
 				if (val === "low" || val === "medium" || val === "high") {
 					const next = saveConfig({ defaultThinking: val as ThinkingTier });
-					ui?.notify(`tool default thinking set to ${next.defaultThinking}`, "info");
+					ui?.notify(`AskAntigravity default thinking set to ${next.defaultThinking}`, "info");
 				} else {
-					ui?.notify(`tool thinking: ${loadConfig().defaultThinking}\nusage: /agy thinking low|medium|high`, "info");
+					ui?.notify(`AskAntigravity thinking: ${loadConfig().defaultThinking} (fallback; callers may override per call)\nusage: /agy thinking low|medium|high`, "info");
 				}
 				return;
 			}
@@ -640,12 +711,23 @@ function registerAgyCommand(pi: ExtensionAPI, ctx: AgyCommandCtx): void {
 	});
 }
 
-/** Interactive settings picker (TUI only). Rows: mode + permissions + model + thinking. */
+/** Interactive settings picker (TUI only). Rows: the full runtime config
+ *  surface (engine, mode, permissions, model, thinking, bridge, digest,
+ *  system prompt). Picking acp runs the same self-service setup as
+ *  `/agy engine acp` (binary + auth) right after the save. */
 async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promise<void> {
 	const config = loadConfig();
 	const pending: PendingConfig = {};
 
 	const items: SettingItem[] = [
+		{
+			id: "engine",
+			label: "Turn engine",
+			description:
+				"stream-json: the streaming engine (default, supported). acp: Google's official ACP server (experimental, opt-in). Switch takes effect on the next pi start (or /reload); acp also runs binary + auth setup on save.",
+			currentValue: config.engine,
+			values: ["stream-json", "acp"],
+		},
 		{
 			id: "mode",
 			label: "Execution mode",
@@ -662,22 +744,54 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 			currentValue: config.skipPermissions ? "auto-approved" : "prompt",
 			values: ["auto-approved", "prompt"],
 		},
+		{
+			id: "ask",
+			label: "AskAntigravity tool",
+			description:
+				"Register the AskAntigravity one-shot delegation tool. off removes it from the model's tool list (provider and models stay, even with the separate pi-ask-antigravity package installed). Takes effect on the next pi start (or /reload).",
+			currentValue: config.askTool ? "on" : "off",
+			values: ["on", "off"],
+		},
 		{
 			id: "model",
-			label: "Tool default model",
+			label: "AskAntigravity model",
 			description:
-				"Alias used when the AskAntigravity tool omits its model param. flash/pro/gemini, or an exact id.",
+				"AskAntigravity one-shot delegation tool: model used when its caller omits the model param. Callers may override per call; this is only the fallback. flash/pro/gemini, or an exact id. Does not affect the provider model you pick in /model.",
 			currentValue: config.defaultModel,
 			values: ["flash", "pro", "gemini"],
 		},
 		{
 			id: "thinking",
-			label: "Tool default thinking",
+			label: "AskAntigravity thinking",
 			description:
-				"Thinking tier used when the model alias names none. Pro has no Medium; it falls back to nearest.",
+				"AskAntigravity one-shot delegation tool: thinking tier used when the call names none. Callers may override per call; this is only the fallback. Pro has no Medium; it falls back to nearest.",
 			currentValue: config.defaultThinking,
 			values: ["low", "medium", "high"],
 		},
+		{
+			id: "bridge",
+			label: "Bridge tools",
+			description:
+				"Which pi tools the MCP bridge exposes to agy. all: every non-builtin tool (default). mcp: pi-mcp-adapter tools + skills. none: bridge off.",
+			currentValue: config.bridgeTools,
+			values: ["all", "mcp", "none"],
+		},
+		{
+			id: "digest",
+			label: "Context digest",
+			description:
+				"Inject a delta of pi-side context into each agy prompt. Defeats agy's prompt cache (~25-30k tokens re-billed per turn).",
+			currentValue: config.digest ? "on" : "off",
+			values: ["on", "off"],
+		},
+		{
+			id: "system-prompt",
+			label: "System prompt",
+			description:
+				"Prepend pi's system prompt (incl. AGENTS.md files) to the first prompt of each new agy conversation.",
+			currentValue: config.systemPrompt ? "on" : "off",
+			values: ["on", "off"],
+		},
 	];
 
 	await ui.custom((tui, theme, _kb, done) => {
@@ -690,7 +804,9 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 			Math.min(items.length + 4, 15),
 			getSettingsListTheme(),
 			(id, newValue) => {
-				if (id === "mode") {
+				if (id === "engine") {
+					pending.engine = newValue as Engine;
+				} else if (id === "mode") {
 					pending.mode = newValue as AgyMode;
 				} else if (id === "permissions") {
 					pending.skipPermissions = newValue === "auto-approved";
@@ -698,6 +814,14 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 					pending.defaultModel = newValue;
 				} else if (id === "thinking") {
 					pending.defaultThinking = newValue as ThinkingTier;
+				} else if (id === "ask") {
+					pending.askTool = newValue === "on";
+				} else if (id === "bridge") {
+					pending.bridgeTools = newValue as BridgeTools;
+				} else if (id === "digest") {
+					pending.digest = newValue === "on";
+				} else if (id === "system-prompt") {
+					pending.systemPrompt = newValue === "on";
 				}
 			},
 			() => done(undefined),
@@ -714,37 +838,65 @@ async function openAgyPicker(ui: ExtensionUIContext, ctx: AgyCommandCtx): Promis
 		};
 	});
 
-	if (
-		pending.mode === undefined &&
-		pending.skipPermissions === undefined &&
-		pending.defaultModel === undefined &&
-		pending.defaultThinking === undefined
-	)
-		return;
+	if (Object.keys(pending).length === 0) return;
 
-	if (pending.mode === "plan" && ctx.engine === "acp") {
-		ui.notify("the ACP engine has no plan mode (RC01). Switch /agy engine stream-json first.", "warning");
+	// The engine latches at load: a plan mode active while the effective
+	// engine is (or will be) acp would silently run non-plan. ACP has no
+	// review-only mode (RC01); refuse the combination. Both sides fall back
+	// to the on-disk config so a fresh engine pick over a saved plan (and
+	// vice versa) is caught too.
+	const nextEngine = pending.engine ?? ctx.engine;
+	const nextMode = pending.mode ?? config.mode;
+	if (nextMode === "plan" && nextEngine === "acp") {
+		ui.notify(
+			"plan + acp is not supported (RC01): the ACP engine has no review-only mode. Save mode accept-edits or pick the stream-json engine first.",
+			"warning",
+		);
 		return;
 	}
 
 	try {
 		const next = saveConfig(pending);
 		const changed = [
+			pending.engine !== undefined ? `engine=${next.engine}` : null,
 			pending.mode ? `mode=${next.mode}` : null,
 			pending.skipPermissions !== undefined
 				? `permissions=${next.skipPermissions ? "auto-approved" : "prompt"}`
 				: null,
-			pending.defaultModel !== undefined ? `tool model=${next.defaultModel}` : null,
-			pending.defaultThinking !== undefined ? `tool thinking=${next.defaultThinking}` : null,
+			pending.askTool !== undefined ? `AskAntigravity tool=${next.askTool ? "on" : "off"}` : null,
+			pending.defaultModel !== undefined ? `AskAntigravity model=${next.defaultModel}` : null,
+			pending.defaultThinking !== undefined ? `AskAntigravity thinking=${next.defaultThinking}` : null,
+			pending.bridgeTools !== undefined ? `bridge=${next.bridgeTools}` : null,
+			pending.digest !== undefined ? `digest=${next.digest ? "on" : "off"}` : null,
+			pending.systemPrompt !== undefined ? `system-prompt=${next.systemPrompt ? "on" : "off"}` : null,
 		]
 			.filter(Boolean)
 			.join(", ");
 		ui.notify(`Saved: ${changed}`, "info");
+		if (pending.engine === "acp") {
+			// Same flow as /agy engine acp: persist the switch, then prepare
+			// the server so the restart just works.
+			ui.notify("Preparing the ACP server (binary + auth)…", "info");
+			const status = await ensureAcpReady({
+				configBin: loadConfig().acp.bin,
+				onProgress: (m) => ui.notify(m, "info"),
+			});
+			if (status.ok) {
+				saveConfig({ acp: { bin: status.bin, permissions: loadConfig().acp.permissions } });
+				ui.notify(
+					status.needsLogin
+						? `ACP server ready. ${acpLoginPending("Your first ACP message (after the restart) opens the browser;")}`
+						: `ACP server ready (auth: ${status.auth}).`,
+					"info",
+				);
+			} else {
+				ui.notify(`ACP auto-setup failed (${status.error}).\n${status.manual}`, "warning");
+			}
+		}
 	} catch (err) {
 		ui.notify(
 			`Failed to save config: ${err instanceof Error ? err.message : String(err)}`,
 			"error",
 		);
 	}
-	void ctx;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-antigravity-bridge",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "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/config.ts

@@ -54,13 +54,20 @@ export interface AgyConfig {
 	defaultModel: string;
 	/** AskAntigravity tool: default thinking tier when the alias names none. */
 	defaultThinking: ThinkingTier;
+	/** Register the AskAntigravity one-shot delegation tool. Default on.
+	 *  off removes the tool entirely for users who want only the provider
+	 *  and models (no delegation tool in the model's window context).
+	 *  Takes effect at pi start (or /reload). */
+	askTool: boolean;
 	/** Set after the one-time notice about a leftover legacy invokeTool patch
 	 *  on the installed pi. The notice never repeats; /agy patch-cleanup is
 	 *  always available. */
 	patchCleanupNotified?: boolean;
 	/** Which pi tools the MCP bridge exposes to agy: "none" (bridge off),
-	 *  "mcp" (pi-mcp-adapter tools + skills bridge; default), "all" (every
-	 *  registered non-builtin tool incl. other Ask* delegations). */
+	 *  "all" (every registered non-builtin tool incl. other Ask* delegations;
+	 *  default - users expect the bridge working out of the box, and the
+	 *  "mcp" surface serves an empty catalog on installs without
+	 *  pi-mcp-adapter), "mcp" (pi-mcp-adapter tools + skills bridge only). */
 	bridgeTools: BridgeTools;
 	/** Inject a delta digest of pi-side context (compaction summaries, turns
 	 *  handled by other providers or pi's own tools) into each agy prompt.
@@ -94,7 +101,8 @@ const DEFAULTS: AgyConfig = {
 	skipPermissions: true,
 	defaultModel: "flash",
 	defaultThinking: "medium",
-	bridgeTools: "mcp",
+	askTool: true,
+	bridgeTools: "all",
 	digest: false,
 	systemPrompt: true,
 	acp: { bin: "", permissions: "auto" },
@@ -147,9 +155,15 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 	const defaultThinking: ThinkingTier =
 		thinkRaw === "low" || thinkRaw === "high" ? thinkRaw : "medium";
 
+	const askTool = process.env.AGY_ASK_TOOL !== undefined
+		? ["1", "true", "on"].includes(process.env.AGY_ASK_TOOL.toLowerCase())
+		: file.askTool ?? DEFAULTS.askTool;
+
 	const bridgeRaw = (process.env.AGY_BRIDGE_TOOLS ?? file.bridgeTools ?? DEFAULTS.bridgeTools).toLowerCase();
 	const bridgeTools: BridgeTools =
-		bridgeRaw === "none" || bridgeRaw === "all" ? bridgeRaw : "mcp";
+		bridgeRaw === "none" || bridgeRaw === "all" || bridgeRaw === "mcp"
+			? bridgeRaw
+			: DEFAULTS.bridgeTools;
 
 	const digest = process.env.AGY_DIGEST !== undefined
 		? ["1", "true", "on"].includes(process.env.AGY_DIGEST.toLowerCase())
@@ -175,6 +189,7 @@ export function loadConfig(configPath: string = CONFIG_PATH): AgyConfig {
 		skipPermissions,
 		defaultModel,
 		defaultThinking,
+		askTool,
 		bridgeTools,
 		digest,
 		systemPrompt,

package/src/skills.ts

@@ -22,7 +22,9 @@ export interface SkillLite {
 	dir: string;
 }
 
-/** Parse `name:` / `description:` out of SKILL.md frontmatter. */
+/** Parse `name:` / `description:` out of SKILL.md frontmatter. Deliberately
+ *  line-based, not YAML: multi-line block scalars (`description: >-`) keep
+ *  only their first line. */
 function parseFrontmatter(raw: string): { name?: string; description?: string } {
 	const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
 	if (!m) return {};
@@ -36,48 +38,123 @@ function parseFrontmatter(raw: string): { name?: string; description?: string }
 	return out;
 }
 
-function scanDir(dir: string): SkillLite[] {
-	let entries: string[];
+// The rest of this module mirrors pi's own skill discovery (pi docs
+// "docs/skills.md - Locations") so the bridge's activate_skill catalog
+// matches the [Skills] list pi shows in its system prompt:
+//
+// - Global: ~/.pi/agent/skills (pi style) and ~/.agents/skills (agents style,
+//   the cross-harness standard).
+// - Project: .pi/skills (pi style) and .agents/skills in cwd + ancestors up
+//   to the git repo root (agents style).
+// - Both styles discover every directory holding a SKILL.md, recursively;
+//   grouping folders (no SKILL.md) are descended into and a skill's contents
+//   are freeform (no descent past its SKILL.md).
+// - pi style also treats root .md files as individual skills; agents style
+//   ignores root .md but picks up frontmatter .md files inside grouping
+//   folders.
+// - Skills without a description are not loaded (same as pi).
+// - Name collisions keep the first skill found, pi global dirs before
+//   project dirs.
+
+export type SkillStyle = "pi" | "agents";
+
+export interface SkillLocation {
+	dir: string;
+	style: SkillStyle;
+}
+
+const MAX_DEPTH = 16; // symlink-loop insurance; real catalogs nest 1-2 levels
+
+/** Ordered skill locations for a session: pi global dirs, then project dirs
+ *  (project `.agents/skills` walks cwd ancestors up to the git root). */
+export function skillLocations(projectDir?: string, home: string = os.homedir()): SkillLocation[] {
+	const out: SkillLocation[] = [
+		{ dir: path.join(home, ".pi", "agent", "skills"), style: "pi" },
+		{ dir: path.join(home, ".agents", "skills"), style: "agents" },
+	];
+	if (!projectDir) return out;
+	out.push({ dir: path.join(projectDir, ".pi", "skills"), style: "pi" });
+	let dir = path.resolve(projectDir);
+	for (;;) {
+		out.push({ dir: path.join(dir, ".agents", "skills"), style: "agents" });
+		if (path.dirname(dir) === dir || fs.existsSync(path.join(dir, ".git"))) break;
+		dir = path.dirname(dir);
+	}
+	return out;
+}
+
+function readSkillFile(file: string, fallbackName: string): SkillLite | null {
+	let raw = "";
 	try {
-		entries = fs.readdirSync(dir, { withFileTypes: true }).map((e) => e.name);
+		// Strip a UTF-8 BOM so editors that add one do not break the `---` anchor.
+		raw = fs.readFileSync(file, "utf8").replace(/^\uFEFF/, "");
 	} catch {
-		return [];
+		return null;
 	}
-	const found: SkillLite[] = [];
-	for (const entry of entries) {
-		const skillDir = path.join(dir, entry);
-		const skillFile = path.join(skillDir, "SKILL.md");
+	const fm = parseFrontmatter(raw);
+	const description = (fm.description ?? "").trim();
+	// pi does not load skills without a description.
+	if (!description) return null;
+	return {
+		name: fm.name?.trim() || fallbackName,
+		description: description.replace(/\s+/g, " ").slice(0, 160),
+		filePath: file,
+		dir: path.dirname(file),
+	};
+}
+
+function scanLocation(loc: SkillLocation): SkillLite[] {
+	const walk = (dir: string, depth: number): SkillLite[] => {
+		if (depth > MAX_DEPTH) return [];
+		let entries: fs.Dirent[];
 		try {
-			if (!fs.statSync(skillFile).isFile()) continue;
+			entries = fs.readdirSync(dir, { withFileTypes: true });
 		} catch {
-			continue;
+			return [];
 		}
-		let raw = "";
-		try {
-			raw = fs.readFileSync(skillFile, "utf8");
-		} catch {
-			continue;
+		const found: SkillLite[] = [];
+		for (const entry of entries) {
+			// Hidden entries are harness internals (e.g. ~/.agents/skills/.system);
+			// pi's own [Skills] list never includes them.
+			if (entry.name.startsWith(".")) continue;
+			const full = path.join(dir, entry.name);
+			let isDir: boolean;
+			try {
+				isDir = entry.isDirectory() || (entry.isSymbolicLink() && fs.statSync(full).isDirectory());
+			} catch {
+				continue;
+			}
+			if (isDir) {
+				if (fs.existsSync(path.join(full, "SKILL.md"))) {
+					const skill = readSkillFile(path.join(full, "SKILL.md"), entry.name);
+					if (skill) found.push(skill);
+				} else {
+					found.push(...walk(full, depth + 1));
+				}
+				continue;
+			}
+			if (!entry.name.endsWith(".md") || entry.name === "SKILL.md") continue;
+			const standalone = loc.style === "pi" ? depth === 0 : depth > 0;
+			if (!standalone) continue;
+			const skill = readSkillFile(full, entry.name.replace(/\.md$/, ""));
+			if (skill) found.push(skill);
 		}
-		const fm = parseFrontmatter(raw);
-		found.push({
-			name: fm.name?.trim() || entry,
-			description: (fm.description ?? "").replace(/\s+/g, " ").slice(0, 160),
-			filePath: skillFile,
-			dir: skillDir,
-		});
-	}
-	return found;
+		return found;
+	};
+	return walk(loc.dir, 0);
 }
 
-/** Unique skills with a file path; first name wins (same as pi collisions). */
-export function scanSkills(projectDir?: string): SkillLite[] {
-	const globalDir = path.join(os.homedir(), ".pi", "agent", "skills");
+/** pi-faithful skill catalog: every skill pi itself would load, deduped by
+ *  name (first wins). `home` is injectable for tests. */
+export function scanSkills(projectDir?: string, home: string = os.homedir()): SkillLite[] {
 	const seen = new Set<string>();
 	const out: SkillLite[] = [];
-	for (const skill of [...scanDir(globalDir), ...(projectDir ? scanDir(path.join(projectDir, ".pi", "skills")) : [])]) {
-		if (!skill.filePath || seen.has(skill.name)) continue;
-		seen.add(skill.name);
-		out.push(skill);
+	for (const loc of skillLocations(projectDir, home)) {
+		for (const skill of scanLocation(loc)) {
+			if (seen.has(skill.name)) continue;
+			seen.add(skill.name);
+			out.push(skill);
+		}
 	}
 	return out;
 }