lsd-pi 1.3.7 → 1.3.10

package/src/resources/extensions/mcp-client/mcp-manager-component.ts

@@ -0,0 +1,256 @@
+import type { Theme } from "@gsd/pi-coding-agent";
+import { Key, SelectList, type SelectItem, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+
+export interface McpManagerServerInfo {
+	name: string;
+	enabled: boolean;
+	connected: boolean;
+	transport: string;
+	toolCount: number;
+	sourceLabel: string;
+}
+
+export interface McpManagerCallbacks {
+	getServers: () => McpManagerServerInfo[];
+	onToggle: (name: string) => Promise<McpManagerServerInfo | null>;
+	onInspect: (name: string) => Promise<string>;
+	onReconnect: (name: string) => Promise<McpManagerServerInfo | null>;
+	onClose: () => void;
+	requestRender: () => void;
+}
+
+type ViewMode = "list" | "inspect";
+
+function getSelectListTheme(theme: Theme) {
+	return {
+		selectedPrefix: (text: string) => theme.fg("accent", text),
+		selectedText: (text: string) => theme.fg("accent", text),
+		description: (text: string) => theme.fg("muted", text),
+		scrollInfo: (text: string) => theme.fg("dim", text),
+		noMatch: (text: string) => theme.fg("warning", text),
+	};
+}
+
+function serversToItems(servers: McpManagerServerInfo[]): SelectItem[] {
+	return servers.map((server) => ({
+		value: server.name,
+		label: server.name,
+		description: [
+			server.enabled ? "enabled" : "disabled",
+			server.transport,
+			server.connected ? "● connected" : "○ offline",
+			`${server.toolCount} tools`,
+			server.sourceLabel || undefined,
+		].filter(Boolean).join("  "),
+	}));
+}
+
+export class McpManagerComponent {
+	private readonly theme: Theme;
+	private readonly callbacks: McpManagerCallbacks;
+	private selectList: SelectList;
+	private mode: ViewMode = "list";
+	private inspectServerName = "";
+	private inspectLines: string[] = [];
+	private inspectScrollOffset = 0;
+	private statusMessage = "";
+	private busy = false;
+	private statusTimeout: ReturnType<typeof setTimeout> | null = null;
+
+	constructor(callbacks: McpManagerCallbacks, theme: Theme) {
+		this.callbacks = callbacks;
+		this.theme = theme;
+		this.selectList = new SelectList([], 8, getSelectListTheme(theme));
+		this.bindSelectList();
+		this.refreshList();
+	}
+
+	invalidate(): void {
+		this.selectList.invalidate();
+	}
+
+	dispose(): void {
+		if (this.statusTimeout) {
+			clearTimeout(this.statusTimeout);
+			this.statusTimeout = null;
+		}
+	}
+
+	getMode(): ViewMode {
+		return this.mode;
+	}
+
+	handleInput(data: string): void {
+		if (this.mode === "inspect") {
+			this.handleInspectInput(data);
+			return;
+		}
+
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			this.callbacks.onClose();
+			return;
+		}
+
+		if (data === "i") {
+			void this.handleInspect();
+			return;
+		}
+
+		if (data === "r") {
+			void this.handleReconnect();
+			return;
+		}
+
+		this.selectList.handleInput(data);
+		this.callbacks.requestRender();
+	}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+		const add = (line = "") => lines.push(truncateToWidth(line, width));
+		const divider = this.theme.fg("border", "─".repeat(Math.max(width, 1)));
+
+		add(divider);
+		if (this.mode === "inspect") {
+			add(
+				this.theme.bold(this.theme.fg("toolTitle", ` MCP Tools · ${this.inspectServerName}`)) +
+				this.theme.fg("dim", "  esc/q: back  ↑↓/pgup/pgdn/home/end: scroll"),
+			);
+			add("");
+
+			const bodyHeight = Math.max(8, width > 0 ? 18 : 8);
+			const maxOffset = Math.max(0, this.inspectLines.length - bodyHeight);
+			this.inspectScrollOffset = Math.max(0, Math.min(this.inspectScrollOffset, maxOffset));
+			const visibleLines = this.inspectLines.slice(this.inspectScrollOffset, this.inspectScrollOffset + bodyHeight);
+			for (const line of visibleLines) add(line);
+			if (visibleLines.length === 0) add(this.theme.fg("dim", "  No tool information"));
+			add("");
+			add(divider);
+			add(this.theme.fg("dim", ` ${this.inspectLines.length} lines`));
+			return lines;
+		}
+
+		add(
+			this.theme.bold(this.theme.fg("toolTitle", " MCP Servers")) +
+			this.theme.fg("dim", "  ↑↓ navigate  enter: toggle  i: inspect  r: reconnect  esc: close"),
+		);
+		add("");
+		lines.push(...this.selectList.render(width));
+		add("");
+		add(divider);
+		const servers = this.callbacks.getServers();
+		const enabled = servers.filter((server) => server.enabled).length;
+		let footer = this.theme.fg("dim", ` ${servers.length} servers · ${enabled} enabled`);
+		if (this.busy) footer += this.theme.fg("accent", " · working…");
+		if (this.statusMessage) footer += this.theme.fg("accent", ` — ${this.statusMessage}`);
+		add(footer);
+		return lines;
+	}
+
+	private bindSelectList(): void {
+		this.selectList.onSelect = () => {
+			void this.handleToggle();
+		};
+		this.selectList.onCancel = () => {
+			this.callbacks.onClose();
+		};
+	}
+
+	private refreshList(preferredName?: string): void {
+		const currentSelected = preferredName ?? this.selectList.getSelectedItem()?.value;
+		this.selectList = new SelectList(
+			serversToItems(this.callbacks.getServers()),
+			8,
+			getSelectListTheme(this.theme),
+		);
+		this.bindSelectList();
+		if (currentSelected) {
+			const items = this.callbacks.getServers();
+			const index = items.findIndex((item) => item.name === currentSelected);
+			if (index >= 0) this.selectList.setSelectedIndex(index);
+		}
+		this.callbacks.requestRender();
+	}
+
+	private setStatus(message: string): void {
+		this.statusMessage = message;
+		this.callbacks.requestRender();
+		if (this.statusTimeout) clearTimeout(this.statusTimeout);
+		if (!message) return;
+		this.statusTimeout = setTimeout(() => {
+			this.statusMessage = "";
+			this.callbacks.requestRender();
+		}, 3000);
+		this.statusTimeout.unref?.();
+	}
+
+	private getSelectedName(): string | undefined {
+		return this.selectList.getSelectedItem()?.value;
+	}
+
+	private async runBusy(task: () => Promise<void>): Promise<void> {
+		if (this.busy) return;
+		this.busy = true;
+		this.callbacks.requestRender();
+		try {
+			await task();
+		} finally {
+			this.busy = false;
+			this.callbacks.requestRender();
+		}
+	}
+
+	private async handleToggle(): Promise<void> {
+		const name = this.getSelectedName();
+		if (!name) return;
+		await this.runBusy(async () => {
+			this.setStatus(`Toggling ${name}...`);
+			const updated = await this.callbacks.onToggle(name);
+			this.refreshList(updated?.name ?? name);
+			if (updated) {
+				this.setStatus(`${updated.name}: ${updated.enabled ? "enabled" : "disabled"}`);
+			}
+		});
+	}
+
+	private async handleInspect(): Promise<void> {
+		const name = this.getSelectedName();
+		if (!name) return;
+		await this.runBusy(async () => {
+			this.setStatus(`Loading tools for ${name}...`);
+			const text = await this.callbacks.onInspect(name);
+			this.inspectServerName = name;
+			this.inspectLines = text.split("\n");
+			this.inspectScrollOffset = 0;
+			this.mode = "inspect";
+			this.setStatus("");
+		});
+	}
+
+	private async handleReconnect(): Promise<void> {
+		const name = this.getSelectedName();
+		if (!name) return;
+		await this.runBusy(async () => {
+			this.setStatus(`Reconnecting ${name}...`);
+			const updated = await this.callbacks.onReconnect(name);
+			this.refreshList(updated?.name ?? name);
+			this.setStatus(updated ? `${updated.name}: reconnected` : `${name}: reconnect failed`);
+		});
+	}
+
+	private handleInspectInput(data: string): void {
+		if (matchesKey(data, Key.escape) || data === "q") {
+			this.mode = "list";
+			this.callbacks.requestRender();
+			return;
+		}
+		const page = 12;
+		if (matchesKey(data, Key.up)) this.inspectScrollOffset -= 1;
+		else if (matchesKey(data, Key.down)) this.inspectScrollOffset += 1;
+		else if (matchesKey(data, Key.pageUp)) this.inspectScrollOffset -= page;
+		else if (matchesKey(data, Key.pageDown)) this.inspectScrollOffset += page;
+		else if (matchesKey(data, Key.home)) this.inspectScrollOffset = 0;
+		else if (matchesKey(data, Key.end)) this.inspectScrollOffset = Number.MAX_SAFE_INTEGER;
+		this.callbacks.requestRender();
+	}
+}

package/src/resources/extensions/mcp-client/tests/mcp-manager-component.test.ts

@@ -0,0 +1,141 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+
+import { McpManagerComponent, type McpManagerCallbacks, type McpManagerServerInfo } from "../mcp-manager-component.js";
+
+function createTheme() {
+	return {
+		fg: (_color: string, text: string) => text,
+		bold: (text: string) => text,
+	} as any;
+}
+
+function createCallbacks(overrides?: Partial<McpManagerCallbacks> & { servers?: McpManagerServerInfo[] }) {
+	let servers = overrides?.servers ?? [];
+	let closed = false;
+	let renderCount = 0;
+	const callbacks: McpManagerCallbacks = {
+		getServers: () => servers,
+		onToggle: async () => null,
+		onInspect: async () => "",
+		onReconnect: async () => null,
+		onClose: () => {
+			closed = true;
+		},
+		requestRender: () => {
+			renderCount += 1;
+		},
+		...overrides,
+	};
+	return {
+		callbacks,
+		getClosed: () => closed,
+		getRenderCount: () => renderCount,
+		setServers: (next: McpManagerServerInfo[]) => {
+			servers = next;
+		},
+	};
+}
+
+test("McpManagerComponent renders server list", () => {
+	const { callbacks } = createCallbacks({
+		servers: [{
+			name: "alpha",
+			enabled: true,
+			connected: true,
+			transport: "stdio",
+			toolCount: 3,
+			sourceLabel: "project",
+		}],
+	});
+	const component = new McpManagerComponent(callbacks, createTheme());
+	const rendered = stripAnsi(component.render(100).join("\n"));
+	assert.match(rendered, /MCP Servers/);
+	assert.match(rendered, /alpha/);
+	assert.match(rendered, /3 tools/);
+});
+
+test("McpManagerComponent toggles and refreshes latest server state", async () => {
+	const state: McpManagerServerInfo = {
+		name: "alpha",
+		enabled: true,
+		connected: true,
+		transport: "stdio",
+		toolCount: 2,
+		sourceLabel: "project",
+	};
+	const harness = createCallbacks({
+		servers: [state],
+		onToggle: async () => {
+			const next = { ...state, enabled: false, connected: false, toolCount: 0 };
+			harness.setServers([next]);
+			return next;
+		},
+	});
+	const component = new McpManagerComponent(harness.callbacks, createTheme());
+	await (component as any).handleToggle();
+	const rendered = stripAnsi(component.render(100).join("\n"));
+	assert.match(rendered, /disabled/);
+	assert.match(rendered, /0 tools/);
+});
+
+test("McpManagerComponent inspects tools and switches mode", async () => {
+	const { callbacks } = createCallbacks({
+		servers: [{
+			name: "alpha",
+			enabled: true,
+			connected: true,
+			transport: "stdio",
+			toolCount: 2,
+			sourceLabel: "project",
+		}],
+		onInspect: async () => "alpha — 2 tools\n\n## search\nFind stuff",
+	});
+	const component = new McpManagerComponent(callbacks, createTheme());
+	await (component as any).handleInspect();
+	assert.equal(component.getMode(), "inspect");
+	const rendered = stripAnsi(component.render(100).join("\n"));
+	assert.match(rendered, /MCP Tools · alpha/);
+	assert.match(rendered, /## search/);
+});
+
+test("McpManagerComponent reconnect refreshes server details", async () => {
+	const current: McpManagerServerInfo = {
+		name: "alpha",
+		enabled: true,
+		connected: false,
+		transport: "stdio",
+		toolCount: 0,
+		sourceLabel: "project",
+	};
+	const harness = createCallbacks({
+		servers: [current],
+		onReconnect: async () => {
+			const next = { ...current, connected: true, toolCount: 4 };
+			harness.setServers([next]);
+			return next;
+		},
+	});
+	const component = new McpManagerComponent(harness.callbacks, createTheme());
+	await (component as any).handleReconnect();
+	const rendered = stripAnsi(component.render(100).join("\n"));
+	assert.match(rendered, /4 tools/);
+	assert.match(rendered, /connected/);
+});
+
+test("McpManagerComponent closes on escape in list mode", () => {
+	const harness = createCallbacks({
+		servers: [{
+			name: "alpha",
+			enabled: true,
+			connected: true,
+			transport: "stdio",
+			toolCount: 1,
+			sourceLabel: "project",
+		}],
+	});
+	const component = new McpManagerComponent(harness.callbacks, createTheme());
+	component.handleInput("\x1b");
+	assert.equal(harness.getClosed(), true);
+});

package/src/resources/extensions/mcp-client/tests/server-name-spaces.test.ts

@@ -53,3 +53,35 @@ test("#3029: getOrConnect normalizes name for connection cache lookup", () => {
 		"getOrConnect should use config.name (canonical) as the connections cache key",
 	);
 });
+
+test("enabled MCP servers are warmed up on session start", () => {
+	assert.match(
+		source,
+		/pi\.on\("session_start", async \(_event, ctx\) => {[\s\S]*?warmupEnabledServers\(/,
+		"session_start should trigger MCP autoconnect warmup for enabled servers",
+	);
+});
+
+test("warmupEnabledServers preloads tool schemas during autoconnect", () => {
+	assert.ok(
+		source.includes("async function warmupServer(") &&
+			source.includes("toolCache.set(canonicalName, tools)") &&
+			source.includes("warmupEnabledServers()"),
+		"warmup path should list tools and populate tool cache during startup",
+	);
+});
+
+test("global MCP config path is supported", () => {
+	assert.ok(
+		source.includes('join(homedir(), ".lsd", "mcp.json")'),
+		"readConfigs should include ~/.lsd/mcp.json",
+	);
+});
+
+test("bare /mcp opens interactive manager when custom UI exists", () => {
+	assert.match(
+		source,
+		/if \(!args\.trim\(\) && typeof ctx\.ui\.custom === "function"\) {[\s\S]*?openMcpManager\(ctx\)/,
+		"bare /mcp should open the manager UI when custom UI is available",
+	);
+});

package/src/resources/extensions/slash-commands/plan.ts

@@ -191,8 +191,8 @@ function readAutoSwitchPlanModelSetting(): boolean {
     const settingsPath = join(getAgentDir(), "settings.json");
     if (!existsSync(settingsPath)) return false;
     const raw = readFileSync(settingsPath, "utf-8");
-    const parsed = JSON.parse(raw) as { autoSwitchPlanModel?: unknown };
-    return parsed.autoSwitchPlanModel === true;
+    const parsed = JSON.parse(raw) as { planModeAutoSwitchModel?: unknown };
+    return parsed.planModeAutoSwitchModel === true;
   } catch {
     return false;
   }
@@ -340,8 +340,8 @@ async function setModelIfNeeded(pi: ExtensionAPI, ctx: any, modelRef: ModelRef |
   return true;
 }
 
-function buildExecutionKickoffMessage(options: { permissionMode: RestorablePermissionMode; executeWithSubagent?: boolean }): string {
-  const { permissionMode, executeWithSubagent = false } = options;
+function buildExecutionKickoffMessage(options: { permissionMode: RestorablePermissionMode; executeWithSubagent?: boolean; executionNote?: string }): string {
+  const { permissionMode, executeWithSubagent = false, executionNote } = options;
   const task = state.task.trim();
 
   if (!executeWithSubagent) {
@@ -350,6 +350,10 @@ function buildExecutionKickoffMessage(options: { permissionMode: RestorablePermi
     ];
     if (task) details.push(`Original task: ${task}`);
     if (state.latestPlanPath) details.push(`Use the approved plan artifact at ${state.latestPlanPath} as the execution plan.`);
+    if (executionNote) details.push(`User execution note: ${executionNote}`);
+    details.push(
+      "After implementation: guide the user through verification by presenting a concise checklist based on the plan's Acceptance Criteria and Verification Plan. Run applicable checks (build, lint, tests) and report results.",
+    );
     return details.join(" ");
   }
 
@@ -366,6 +370,16 @@ function buildExecutionKickoffMessage(options: { permissionMode: RestorablePermi
   ];
   if (task) details.push(`Original task: ${task}`);
   if (state.latestPlanPath) details.push(`Primary plan artifact: ${state.latestPlanPath}`);
+  if (executionNote) {
+    details.push(`User execution note: ${executionNote}`);
+    // If the note contains a model request, surface it explicitly so the agent
+    // doesn't silently drop it. The model override will be resolved by
+    // normalizeSubagentModel when the subagent tool is invoked.
+    const modelMatch = executionNote.match(/\b(?:model|use\s+model)\s+["']?([\w.-]+(?:\/[\w.-]+)?)["']?\b/i);
+    if (modelMatch?.[1]) {
+      details.push(`The user explicitly requested model "${modelMatch[1]}". You MUST pass model="${modelMatch[1]}" in the subagent tool call. If normalizeSubagentModel cannot resolve this model, report the error to the user instead of silently falling back.`);
+    }
+  }
   details.push(
     "Important: if the plan is large and you estimate it would exceed a single subagent's context window (~200k tokens), " +
     "split execution across multiple sequential subagents instead of one. " +
@@ -375,7 +389,8 @@ function buildExecutionKickoffMessage(options: { permissionMode: RestorablePermi
   );
   details.push(
     "After all subagents complete: (1) do a quick review of the implementation — check that the plan steps were actually carried out, spot obvious issues or missed pieces, and verify the code compiles/passes lint if applicable. " +
-    "(2) Then summarize what was done, what (if anything) needs follow-up, and flag any concerns found during review.",
+    "(2) Then guide the user through verification: present a concise checklist based on the plan's Acceptance Criteria and Verification Plan sections. Run applicable checks (build, lint, tests) and report results. " +
+    "(3) Summarize what was done, what (if anything) needs follow-up, and flag any concerns found during review.",
   );
   return details.join(" ");
 }
@@ -417,11 +432,12 @@ async function approvePlan(
   ctx: any,
   permissionMode: RestorablePermissionMode,
   executeWithSubagent = false,
+  executionNote?: string,
 ): Promise<void> {
-  const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
-  if (reasoningModel) {
-    await setModelIfNeeded(pi, ctx, reasoningModel);
-  }
+  // Do NOT switch to reasoning model during execution.
+  // The reasoning model is only for plan-mode investigation, not execution.
+  // If a coding model is configured and we're using a subagent, the explicit
+  // model="<planModeCodingModel>" in the kickoff message will handle it.
 
   state = {
     ...state,
@@ -434,7 +450,7 @@ async function approvePlan(
   // subagent tool with the default session model BEFORE it ever sees the
   // explicit model="<planModeCodingModel>" instruction. Steering ensures the
   // configured plan-mode coding model reaches the subagent invocation.
-  await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent }), { deliverAs: "steer" });
+  await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent, executionNote }), { deliverAs: "steer" });
 }
 
 async function cancelPlan(pi: ExtensionAPI, ctx: any, clearTask = true): Promise<RestorablePermissionMode> {
@@ -448,10 +464,12 @@ async function cancelPlan(pi: ExtensionAPI, ctx: any, clearTask = true): Promise
 function buildPlanModeSystemPrompt(): string {
   const details: string[] = [
     "You are currently in plan mode.",
+    "Terse output. All technical substance stays. Only fluff dies. Fragments OK.",
     "Investigate, clarify scope, and produce a persisted execution plan before making source changes.",
     "If requirements are ambiguous or constraints are missing, ask concise clarifying questions before drafting or saving a plan.",
     `Before writing or updating a plan artifact, make sure your confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If confidence is lower, investigate more or ask clarifying questions first.`,
     "Include an explicit confidence line in every saved plan, for example: \"Confidence: 8/10\" or higher.",
+    "Every saved plan MUST include explicit \"Acceptance Criteria\" and \"Verification Plan\" sections. Plans missing these sections will be rejected for approval.",
     "When adjusting an existing saved plan, prefer the edit tool for targeted changes. Rewrite the whole file only when the structure changes substantially or an exact edit is impractical.",
     "Do not modify source files or run side-effect commands while plan mode is active.",
     "Persist plan artifacts under .lsd/plan/.",
@@ -502,6 +520,32 @@ function buildApprovalDialogInstructions(): string {
   return buildApprovalActionInstructions();
 }
 
+/** Required heading patterns for plan artifacts. Matches common variants. */
+const REQUIRED_PLAN_SECTIONS: Array<{ pattern: RegExp; label: string }> = [
+  { pattern: /\b(acceptance\s*criteria|success\s*criteria|done\s*criteria)\b/i, label: "Acceptance Criteria" },
+  { pattern: /\b(verification\s*(plan|steps|strategy)|how\s+to\s+verify|testing\s*plan)\b/i, label: "Verification Plan" },
+];
+
+function validatePlanArtifact(markdown: string): { valid: boolean; missing: string[] } {
+  const missing: string[] = [];
+  for (const section of REQUIRED_PLAN_SECTIONS) {
+    if (!section.pattern.test(markdown)) {
+      missing.push(section.label);
+    }
+  }
+  return { valid: missing.length === 0, missing };
+}
+
+function buildPlanValidationSteeringMessage(planPath: string, missing: string[]): string {
+  const missingList = missing.map((m) => `- **${m}**`).join("\n");
+  return [
+    `Plan artifact saved at ${planPath}.`,
+    `The plan is missing required sections before it can be approved for implementation:`,
+    missingList,
+    `Please revise the plan to include these sections, then re-save. Do not ask for approval until all required sections are present.`,
+  ].join("\n\n");
+}
+
 function buildApprovalSteeringMessage(planPath: string): string {
   return [
     `Plan artifact saved at ${planPath}.`,
@@ -739,13 +783,24 @@ export default function planCommand(pi: ExtensionAPI) {
         }
 
         const planMarkdown = readPlanArtifact(path);
-        pi.sendMessage({
-          customType: "plan-mode-preview",
-          content: buildPlanPreviewMessage(path, planMarkdown),
-          display: true,
-        });
-        ctx.ui?.notify?.("/plan to show plan", "info");
-        pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+        if (!planMarkdown) {
+          ctx.ui?.notify?.("Plan artifact could not be read for validation", "warning");
+          pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+        } else {
+          const validation = validatePlanArtifact(planMarkdown);
+          if (!validation.valid) {
+            ctx.ui?.notify?.("Plan missing required sections — see guidance below", "warning");
+            pi.sendUserMessage(buildPlanValidationSteeringMessage(path, validation.missing), { deliverAs: "steer" });
+          } else {
+            pi.sendMessage({
+              customType: "plan-mode-preview",
+              content: buildPlanPreviewMessage(path, planMarkdown),
+              display: true,
+            });
+            ctx.ui?.notify?.("/plan to show plan", "info");
+            pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+          }
+        }
       }
       return;
     }
@@ -808,12 +863,13 @@ export default function planCommand(pi: ExtensionAPI) {
         permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
         executeWithSubagent: false,
       };
+      const permissionNote = getAnswerNote(permissionAnswer);
       state = { ...state, targetPermissionMode: executionMode.permissionMode };
       if (executionMode.executeWithSubagent) {
         const modeLabel = executionMode.permissionMode === "danger-full-access" ? "bypass" : "auto";
         ctx.ui?.notify?.(`Plan approved: subagent(${modeLabel})`, "info");
       }
-      await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
+      await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent, permissionNote);
       return;
     }
 
@@ -833,12 +889,13 @@ export default function planCommand(pi: ExtensionAPI) {
         permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
         executeWithSubagent: false,
       };
+      const actionNote = getAnswerNote(actionAnswer);
       state = { ...state, targetPermissionMode: executionMode.permissionMode };
       if (executionMode.executeWithSubagent) {
         const modeLabel = executionMode.permissionMode === "danger-full-access" ? "bypass" : "auto";
         ctx.ui?.notify?.(`Plan approved: subagent(${modeLabel})`, "info");
       }
-      await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
+      await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent, actionNote);
       return;
     }
 

package/src/resources/extensions/subagent/agents.ts

@@ -9,6 +9,9 @@ import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 
 const PROJECT_AGENT_DIR_CANDIDATES = [".lsd", ".gsd", ".pi"] as const;
 
+/** Fixed read-only tool set for the reserved `scout` agent. */
+const SCOUT_ALLOWED_TOOLS = ["read", "lsp", "grep", "find", "ls"] as const;
+
 export type AgentScope = "user" | "project" | "both";
 
 export interface AgentConfig {
@@ -143,6 +146,12 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
 		addAgents(projectAgents);
 	}
 
+	// Enforce reserved agent tool policies — scout is always read-only
+	const scout = agentMap.get("scout");
+	if (scout) {
+		scout.tools = [...SCOUT_ALLOWED_TOOLS];
+	}
+
 	return { agents: Array.from(agentMap.values()), projectAgentsDir };
 }