lsd-pi 1.2.4 → 1.3.6

package/src/resources/extensions/shared/interview-ui.ts

@@ -43,6 +43,11 @@ export interface QuestionOption {
 	description: string;
 }
 
+export interface QuestionShowWhen {
+	questionId: string;
+	selectedAnyOf: string[];
+}
+
 export interface Question {
 	id: string;
 	header: string;
@@ -50,6 +55,8 @@ export interface Question {
 	options: QuestionOption[];
 	/** If true, user can toggle multiple options with SPACE, confirm with ENTER */
 	allowMultiple?: boolean;
+	/** Show this question only when a prior question matches one of selectedAnyOf labels */
+	showWhen?: QuestionShowWhen;
 }
 
 export interface RoundResult {
@@ -107,6 +114,19 @@ export interface WrapUpOptions {
 const OTHER_OPTION_LABEL = "None of the above";
 const OTHER_OPTION_DESCRIPTION = "Select to type your own answer.";
 
+function matchesShowWhen(
+	question: Question,
+	answers: Record<string, { selected: string | string[]; notes: string }>,
+): boolean {
+	if (!question.showWhen) return true;
+	const controlling = answers[question.showWhen.questionId];
+	if (!controlling) return false;
+	const selected = Array.isArray(controlling.selected)
+		? controlling.selected
+		: [controlling.selected];
+	return selected.some((value) => question.showWhen?.selectedAnyOf.includes(value));
+}
+
 async function runSequentialInterviewFallback(
 	questions: Question[],
 	ctx: ExtensionCommandContext,
@@ -114,6 +134,9 @@ async function runSequentialInterviewFallback(
 	const answers: Record<string, { selected: string | string[]; notes: string }> = {};
 
 	for (const q of questions) {
+		if (!matchesShowWhen(q, answers)) {
+			continue;
+		}
 		const options = q.options.map((o) => o.label);
 		if (!q.allowMultiple) {
 			options.push(OTHER_OPTION_LABEL);
@@ -252,7 +275,6 @@ export async function showInterviewRound(
 			notesVisible: false,
 		}));
 
-		const isMultiQuestion = questions.length > 1;
 		let currentIdx = 0;
 		let focusNotes = false;
 		let showingReview = false;
@@ -295,13 +317,64 @@ export async function showInterviewRound(
 			getEditor().setText(states[currentIdx].notes);
 		}
 
+		function selectedLabelsForIndex(idx: number): string[] {
+			if (isMultiSelect(idx)) {
+				return Array.from(states[idx].checkedIndices).sort((a, b) => a - b).map((optionIdx) => questions[idx].options[optionIdx]?.label).filter((v): v is string => !!v);
+			}
+			const committed = states[idx].committedIndex;
+			if (committed === null) return [];
+			if (committed < questions[idx].options.length) return [questions[idx].options[committed]?.label].filter((v): v is string => !!v);
+			if (committed === noneOrDoneIdx(idx)) return [OTHER_OPTION_LABEL];
+			return [];
+		}
+
+		function visibleQuestionIndices(): number[] {
+			const visible: number[] = [];
+			for (let i = 0; i < questions.length; i++) {
+				const q = questions[i];
+				if (!q.showWhen) {
+					visible.push(i);
+					continue;
+				}
+				const controllingIdx = questions.findIndex((candidate) => candidate.id === q.showWhen?.questionId);
+				if (controllingIdx < 0 || !visible.includes(controllingIdx)) continue;
+				const selected = selectedLabelsForIndex(controllingIdx);
+				if (selected.some((label) => q.showWhen?.selectedAnyOf.includes(label))) {
+					visible.push(i);
+				}
+			}
+			return visible;
+		}
+
 		function isQuestionAnswered(idx: number): boolean {
 			if (isMultiSelect(idx)) return states[idx].checkedIndices.size > 0;
 			return states[idx].committedIndex !== null;
 		}
 
 		function allAnswered(): boolean {
-			return questions.every((_, i) => isQuestionAnswered(i));
+			const visible = visibleQuestionIndices();
+			return visible.length > 0 && visible.every((i) => isQuestionAnswered(i));
+		}
+
+		function clearQuestionState(idx: number) {
+			states[idx].cursorIndex = 0;
+			states[idx].committedIndex = null;
+			states[idx].checkedIndices.clear();
+			states[idx].notes = "";
+			states[idx].notesVisible = false;
+		}
+
+		function reconcileVisibility() {
+			const visible = new Set(visibleQuestionIndices());
+			for (let i = 0; i < questions.length; i++) {
+				if (!visible.has(i)) clearQuestionState(i);
+			}
+			if (!visible.has(currentIdx)) {
+				const fallback = visibleQuestionIndices()[0] ?? 0;
+				currentIdx = fallback;
+				loadStateToEditor();
+				focusNotes = false;
+			}
 		}
 
 		function switchQuestion(newIdx: number) {
@@ -315,7 +388,9 @@ export async function showInterviewRound(
 
 		function buildResult(): RoundResult {
 			const answers: Record<string, { selected: string | string[]; notes: string }> = {};
+			const visible = new Set(visibleQuestionIndices());
 			for (let i = 0; i < questions.length; i++) {
+				if (!visible.has(i)) continue;
 				const q = questions[i];
 				const st = states[i];
 				const notes = st.notes.trim();
@@ -348,6 +423,8 @@ export async function showInterviewRound(
 				states[currentIdx].committedIndex = states[currentIdx].cursorIndex;
 			}
 
+			reconcileVisibility();
+
 			// Auto-open the notes field when "None of the above" is selected
 			// so the user can immediately provide a free-text explanation
 			// instead of being trapped in a re-asking loop (bug #2715).
@@ -360,10 +437,14 @@ export async function showInterviewRound(
 				return;
 			}
 
-			if (isMultiQuestion && currentIdx < questions.length - 1) {
-				let next = currentIdx + 1;
-				for (let i = 0; i < questions.length; i++) {
-					const candidate = (currentIdx + 1 + i) % questions.length;
+			const visible = visibleQuestionIndices();
+			const currentVisiblePos = visible.indexOf(currentIdx);
+			const isMultiQuestion = visible.length > 1;
+
+			if (isMultiQuestion && currentVisiblePos >= 0 && currentVisiblePos < visible.length - 1) {
+				let next = visible[currentVisiblePos + 1] ?? visible[0] ?? currentIdx;
+				for (let i = 0; i < visible.length; i++) {
+					const candidate = visible[(currentVisiblePos + 1 + i) % visible.length] ?? currentIdx;
 					if (!isQuestionAnswered(candidate)) { next = candidate; break; }
 				}
 				switchQuestion(next);
@@ -396,7 +477,8 @@ export async function showInterviewRound(
 			if (showingReview) {
 				if (matchesKey(data, Key.escape) || matchesKey(data, Key.left)) {
 					showingReview = false;
-					switchQuestion(questions.length - 1);
+					const visible = visibleQuestionIndices();
+					switchQuestion(visible[visible.length - 1] ?? 0);
 					return;
 				}
 				if (matchesKey(data, Key.enter) || matchesKey(data, Key.right) || matchesKey(data, Key.space)) {
@@ -447,9 +529,14 @@ export async function showInterviewRound(
 			}
 
 			// ── Multi-question navigation ────────────────────────────────
+			const visible = visibleQuestionIndices();
+			const isMultiQuestion = visible.length > 1;
 			if (isMultiQuestion) {
-				if (matchesKey(data, Key.left)) { switchQuestion((currentIdx - 1 + questions.length) % questions.length); return; }
-				if (matchesKey(data, Key.right)) { switchQuestion((currentIdx + 1) % questions.length); return; }
+				const visiblePos = visible.indexOf(currentIdx);
+				if (visiblePos >= 0) {
+					if (matchesKey(data, Key.left)) { switchQuestion(visible[(visiblePos - 1 + visible.length) % visible.length] ?? currentIdx); return; }
+					if (matchesKey(data, Key.right)) { switchQuestion(visible[(visiblePos + 1) % visible.length] ?? currentIdx); return; }
+				}
 			}
 
 			// ── Cursor navigation ────────────────────────────────────────
@@ -488,7 +575,8 @@ export async function showInterviewRound(
 
 			push(ui.bar(), ui.blank(), ui.header(`  ${opts.reviewHeadline ?? "Review your answers"}`), ui.blank());
 
-			for (let i = 0; i < questions.length; i++) {
+			const visible = visibleQuestionIndices();
+			for (const i of visible) {
 				const q = questions[i];
 				const st = states[i];
 
@@ -571,6 +659,11 @@ export async function showInterviewRound(
 			const lines: string[] = [];
 			const push = (...rows: string[][]) => { for (const r of rows) lines.push(...r); };
 
+			reconcileVisibility();
+			const visible = visibleQuestionIndices();
+			const isMultiQuestion = visible.length > 1;
+			const visiblePos = Math.max(visible.indexOf(currentIdx), 0);
+
 			const q = questions[currentIdx];
 			const st = states[currentIdx];
 			const multiSel = isMultiSelect(currentIdx);
@@ -579,13 +672,13 @@ export async function showInterviewRound(
 
 			// ── Progress header ────────────────────────────────────────────
 			if (isMultiQuestion) {
-				const unanswered = questions.filter((_, i) => !isQuestionAnswered(i)).length;
-				const answeredSet = new Set(questions.map((_, i) => i).filter(i => isQuestionAnswered(i)));
-				push(ui.questionTabs(questions.map(q => q.header), currentIdx, answeredSet));
+				const unanswered = visible.filter((i) => !isQuestionAnswered(i)).length;
+				const answeredSet = new Set(visible.map((i, visibleIndex) => (isQuestionAnswered(i) ? visibleIndex : -1)).filter((i) => i >= 0));
+				push(ui.questionTabs(visible.map((i) => questions[i]?.header ?? ""), visiblePos, answeredSet));
 				push(ui.blank());
 				const progressParts = [
 					opts.progress,
-					`Question ${currentIdx + 1}/${questions.length}`,
+					`Question ${visiblePos + 1}/${visible.length}`,
 					unanswered > 0 ? `${unanswered} unanswered` : null,
 				].filter(Boolean).join("  •  ");
 				if (progressParts) push(ui.meta(`  ${progressParts}`));
@@ -647,7 +740,7 @@ export async function showInterviewRound(
 
 			// ── Footer hints ───────────────────────────────────────────────
 			push(ui.blank());
-			const isLast = !isMultiQuestion || currentIdx === questions.length - 1;
+			const isLast = !isMultiQuestion || visiblePos === visible.length - 1;
 			const hints: string[] = [];
 			if (focusNotes) {
 				hints.push("enter to confirm");

package/src/resources/extensions/shared/tests/ask-user-freetext.test.ts

@@ -131,6 +131,67 @@ describe("ask-user-questions RPC fallback free-text", () => {
 		assert.deepStrictEqual(parsed.answers.q1.answers, ["Option A"]);
 	});
 
+	it("skips conditional follow-up when controlling answer does not match", async () => {
+		const tool = captureTool();
+		const { ctx, selectCalls } = makeMockCtx({
+			selectReturns: ["Review plan"],
+		});
+
+		const result = await tool.execute(
+			"call-conditional-skip",
+			{
+				questions: [
+					makeQuestion("plan_mode_approval_action", ["Approve plan", "Review plan"]),
+					{
+						...makeQuestion("plan_mode_approval_permission", ["Auto mode", "Bypass mode"]),
+						showWhen: {
+							questionId: "plan_mode_approval_action",
+							selectedAnyOf: ["Approve plan"],
+						},
+					},
+				],
+			},
+			undefined,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(selectCalls.length, 1);
+		const parsed = JSON.parse(result.content[0]?.text ?? "{}");
+		assert.ok(parsed.answers.plan_mode_approval_action);
+		assert.equal(parsed.answers.plan_mode_approval_permission, undefined);
+	});
+
+	it("asks conditional follow-up when controlling answer matches", async () => {
+		const tool = captureTool();
+		const { ctx, selectCalls } = makeMockCtx({
+			selectReturns: ["Approve plan", "Auto mode"],
+		});
+
+		const result = await tool.execute(
+			"call-conditional-show",
+			{
+				questions: [
+					makeQuestion("plan_mode_approval_action", ["Approve plan", "Review plan"]),
+					{
+						...makeQuestion("plan_mode_approval_permission", ["Auto mode", "Bypass mode"]),
+						showWhen: {
+							questionId: "plan_mode_approval_action",
+							selectedAnyOf: ["Approve plan"],
+						},
+					},
+				],
+			},
+			undefined,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(selectCalls.length, 2);
+		const parsed = JSON.parse(result.content[0]?.text ?? "{}");
+		assert.deepStrictEqual(parsed.answers.plan_mode_approval_permission.answers, ["Auto mode"]);
+	});
+
 	it("handles cancelled free-text input gracefully", async () => {
 		const tool = captureTool();
 		const { ctx, inputCalls } = makeMockCtx({

package/src/resources/extensions/shared/tests/custom-ui-fallbacks.test.ts

@@ -73,6 +73,52 @@ describe("custom UI fallback paths", () => {
 		assert.equal(result.answers.q1?.notes, "My custom answer");
 	});
 
+	it("showInterviewRound skips conditional question when condition is not met", async () => {
+		const selectCalls: Array<{ title: string; options: string[] }> = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				custom: async () => undefined,
+				select: async (title: string, options: string[]) => {
+					selectCalls.push({ title, options });
+					if (title.startsWith("Q1:")) return "Review";
+					return options[0];
+				},
+				input: async () => "",
+			},
+		};
+
+		const result = await showInterviewRound(
+			[
+				{
+					id: "q1",
+					header: "Q1",
+					question: "Approve?",
+					options: [
+						{ label: "Approve", description: "approve" },
+						{ label: "Review", description: "review" },
+					],
+				},
+				{
+					id: "q2",
+					header: "Q2",
+					question: "Mode?",
+					options: [
+						{ label: "Auto", description: "auto" },
+						{ label: "Bypass", description: "bypass" },
+					],
+					showWhen: { questionId: "q1", selectedAnyOf: ["Approve"] },
+				},
+			],
+			{},
+			ctx as any,
+		);
+
+		assert.equal(selectCalls.length, 1, "conditional question should be skipped in fallback mode");
+		assert.equal(result.answers.q1?.selected, "Review");
+		assert.equal(result.answers.q2, undefined);
+	});
+
 	it("collectOneSecret respects null from secure UI and does not fall back to plaintext input", async () => {
 		let inputCalls = 0;
 		const notifications: Array<{ message: string; type?: string }> = [];

package/src/resources/extensions/slash-commands/extension-manifest.json

@@ -2,11 +2,11 @@
 	"id": "slash-commands",
 	"name": "Slash Commands",
 	"version": "1.0.0",
-	"description": "Bundled slash commands for context inspection, planning, and lazy tool search",
+	"description": "Bundled slash commands for context inspection, planning, fast mode, and lazy tool search",
 	"tier": "bundled",
 	"requires": { "platform": ">=2.29.0" },
 	"provides": {
-		"commands": ["audit", "clear", "context", "plan", "execute", "cancel-plan", "tools"],
+		"commands": ["audit", "clear", "context", "fast", "plan", "execute", "cancel-plan", "tools"],
 		"tools": ["tool_search", "tool_enable"],
 		"flags": ["plan"]
 	}

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

@@ -0,0 +1,89 @@
+import { getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+type FastCommandAction = "toggle" | "on" | "off" | "status" | "invalid";
+
+function parseFastCommandAction(args: string): FastCommandAction {
+	const normalized = args.trim().toLowerCase();
+	if (!normalized) return "toggle";
+	if (normalized === "on") return "on";
+	if (normalized === "off") return "off";
+	if (normalized === "status") return "status";
+	return "invalid";
+}
+
+function supportsFastMode(model: ExtensionCommandContext["model"]): boolean {
+	if (!model) return false;
+	if (model.api === "openai-codex-responses") return true;
+	if (model.api !== "openai-responses") return false;
+	if (model.provider !== "openai") return false;
+	return model.capabilities?.supportsServiceTier === true;
+}
+
+function getModelLabel(model: ExtensionCommandContext["model"]): string {
+	if (!model) return "no active model";
+	return `${model.provider}/${model.id}`;
+}
+
+function getSettingsManager(): SettingsManager {
+	return SettingsManager.create(process.cwd(), getAgentDir());
+}
+
+export const __testing = {
+	parseFastCommandAction,
+	supportsFastMode,
+};
+
+export default function fastCommand(pi: ExtensionAPI) {
+	pi.registerCommand("fast", {
+		description: "Toggle fast mode for OpenAI/Codex models (service_tier=priority)",
+		getArgumentCompletions(prefix: string) {
+			const options = [
+				{ value: "on", label: "on", description: "Enable fast mode" },
+				{ value: "off", label: "off", description: "Disable fast mode" },
+				{ value: "status", label: "status", description: "Show current fast-mode status" },
+			];
+			const query = prefix.trim().toLowerCase();
+			return options.filter((item) => item.value.startsWith(query));
+		},
+		async handler(args: string, ctx: ExtensionCommandContext) {
+			const settings = getSettingsManager() as SettingsManager & {
+				getFastMode: () => boolean;
+				setFastMode: (enabled: boolean) => void;
+			};
+			const current = settings.getFastMode();
+			const action = parseFastCommandAction(args);
+			const model = ctx.model;
+			const supported = supportsFastMode(model);
+			const modelLabel = getModelLabel(model);
+
+			if (action === "invalid") {
+				ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+				return;
+			}
+
+			if (action === "status") {
+				ctx.ui.notify(
+					`Fast mode: ${current ? "ON" : "OFF"} · model ${modelLabel} is ${supported ? "supported" : "unsupported"}`,
+					"info",
+				);
+				return;
+			}
+
+			const next = action === "toggle" ? !current : action === "on";
+			settings.setFastMode(next);
+
+			if (!supported) {
+				ctx.ui.notify(
+					`Fast mode: ${next ? "ON" : "OFF"} (saved). Current model ${modelLabel} does not support fast mode.`,
+					"warning",
+				);
+				return;
+			}
+
+			ctx.ui.notify(
+				`Fast mode: ${next ? "ON" : "OFF"} (saved). ${next ? "Requests will include service_tier=priority." : "Requests will omit service_tier."}`,
+				"info",
+			);
+		},
+	});
+}

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

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import contextCommand from "./context.js";
+import fastCommand from "./fast.js";
 import initCommand from "./init.js";
 import planCommand from "./plan.js";
 import toolSearchExtension from "./tools.js";
@@ -10,6 +11,7 @@ export default function slashCommands(pi: ExtensionAPI) {
     auditCommand(pi);
     clearCommand(pi);
     contextCommand(pi);
+    fastCommand(pi);
     initCommand(pi);
     planCommand(pi);
     toolSearchExtension(pi);

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

@@ -38,9 +38,8 @@ const BLOCKED_TOOLS = new Set([
   "async_bash",
   "bg_shell",
   "browser_navigate",
-  "browser_go_back",
-  "browser_go_forward",
-  "browser_reload",
+  "browser_pages",
+  "browser_frames",
   "browser_click",
   "browser_drag",
   "browser_type",
@@ -51,18 +50,13 @@ const BLOCKED_TOOLS = new Set([
   "browser_select_option",
   "browser_set_checked",
   "browser_set_viewport",
-  "browser_click_ref",
-  "browser_hover_ref",
-  "browser_fill_ref",
+  "browser_ref",
   "browser_act",
   "browser_batch",
   "browser_fill_form",
-  "browser_mock_route",
-  "browser_block_urls",
-  "browser_clear_routes",
+  "browser_network",
   "browser_emulate_device",
-  "browser_save_state",
-  "browser_restore_state",
+  "browser_state",
   "browser_generate_test",
   "browser_verify",
   "write",
@@ -80,6 +74,7 @@ const REVISE_LABEL = "Revise plan";
 const CANCEL_LABEL = "Cancel";
 const DEFAULT_PLAN_REVIEW_AGENT = "generic";
 const DEFAULT_PLAN_CODING_AGENT = "worker";
+const MIN_PLAN_CONFIDENCE = 8;
 
 type PlanApprovalStatus = "pending" | "approved" | "revising" | "cancelled";
 type RestorablePermissionMode = Exclude<PermissionMode, "plan">;
@@ -455,6 +450,9 @@ function buildPlanModeSystemPrompt(): string {
     "You are currently in plan mode.",
     "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.",
+    "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/.",
   ];
@@ -483,28 +481,19 @@ function buildNewSessionOptionLabel(): string {
 }
 
 function buildApprovalActionInstructions(): string {
-  return [
-    "Ask for plan approval now using ask_user_questions.",
-    `One single-select question with id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\". Ask what to do next with the plan.`,
-    `Options: ${APPROVE_LABEL}, ${REVIEW_LABEL}, ${REVISE_LABEL}.`,
-    `Do not include \"${CANCEL_LABEL}\" as an explicit option — if the user wants to cancel they should choose \"None of the above\" and type \"${CANCEL_LABEL}\" in the note.`,
-    "Do not restate the plan. Just show the question.",
-  ].join(" ");
-}
-
-function buildApprovalModeInstructions(): string {
   const autoSwitchEnabled = readAutoSwitchPlanModelSetting();
   const showNewSessionOption = autoSwitchEnabled;
   const newSessionLabel = buildNewSessionOptionLabel();
 
-  const options = showNewSessionOption
-    ? `${APPROVE_AUTO_LABEL}, ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}, ${newSessionLabel}`
-    : `${APPROVE_AUTO_LABEL}, ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}`;
-
   return [
-    "Plan approved. Now ask which execution mode to use via ask_user_questions.",
-    `One single-select question with id \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\".`,
-    `Options: ${options}.`,
+    "Ask for plan approval now via exactly one ask_user_questions tool call.",
+    `Question 1 (single-select) id \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\": ask what to do next with the plan. In the question text, tell the user that if they choose \"${REVISE_LABEL}\" they should type exact requested changes in the dialog notes field before submitting.`,
+    `Question 1 options: ${APPROVE_LABEL}, ${REVIEW_LABEL}, ${REVISE_LABEL}. Put "${APPROVE_LABEL}" first with a "(Recommended)" suffix in the description, not in the label.`,
+    `Do not include \"${CANCEL_LABEL}\" as an explicit option — if the user wants to cancel they should choose \"None of the above\" and type \"${CANCEL_LABEL}\" in the note.`,
+    `Question 2 (single-select) id \"${PLAN_APPROVAL_PERMISSION_QUESTION_ID}\": ask which execution mode to use.`,
+    `Question 2 options: ${APPROVE_AUTO_LABEL} (Recommended), ${APPROVE_BYPASS_LABEL}, ${APPROVE_AUTO_SUBAGENT_LABEL}, ${APPROVE_BYPASS_SUBAGENT_LABEL}${showNewSessionOption ? `, ${newSessionLabel}` : ""}.`,
+    `Set question 2 showWhen.questionId to \"${PLAN_APPROVAL_ACTION_QUESTION_ID}\" and showWhen.selectedAnyOf to [\"${APPROVE_LABEL}\"] so it appears only when the user selects Approve plan.`,
+    "Do not restate the plan in a normal assistant response. Just call ask_user_questions.",
   ].join(" ");
 }
 
@@ -569,6 +558,25 @@ function buildReviewSteeringMessage(planPath: string, planMarkdown?: string): st
   return details.join("\n\n");
 }
 
+function buildRevisionSteeringMessage(planPath: string, requestedChanges?: string): string {
+  const details = [
+    `The user selected \"${REVISE_LABEL}\" for ${planPath}.`,
+    "Revise the existing saved plan instead of drafting a fresh replacement unless a full rewrite is genuinely necessary.",
+    "Prefer the edit tool for targeted adjustments to the current plan artifact. Use write only if the structure changes substantially or an exact edit is impractical.",
+    `Before saving the revised plan, make sure confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If lower, investigate more or ask clarifying questions first.`,
+    "Keep an explicit confidence line in the plan, for example: \"Confidence: 8/10\" or higher.",
+  ];
+
+  if (requestedChanges) {
+    details.push(`User-requested changes: ${requestedChanges}`);
+  } else {
+    details.push("No concrete revision note was provided yet. Ask one concise clarifying question about what should change before editing the plan.");
+  }
+
+  details.push("After revising the saved plan artifact, ask for approval again.");
+  return details.join("\n\n");
+}
+
 function approvalSelectionToExecutionMode(
   selected: string | undefined,
 ): { permissionMode: RestorablePermissionMode; executeWithSubagent: boolean } | undefined {
@@ -598,6 +606,12 @@ function getAnswerValues(answer: AskUserAnswer | undefined): string[] {
   return values;
 }
 
+function getAnswerNote(answer: AskUserAnswer | undefined): string | undefined {
+  if (typeof answer?.notes !== "string") return undefined;
+  const note = answer.notes.trim();
+  return note.length > 0 ? note : undefined;
+}
+
 function selectionRequestsCancel(selected: string[]): boolean {
   return selected.some((value) => {
     if (typeof value !== "string") return false;
@@ -621,6 +635,8 @@ export const __testing = {
   buildApprovalSteeringMessage,
   buildPlanPreviewMessage,
   buildReviewSteeringMessage,
+  buildRevisionSteeringMessage,
+  buildPlanModeSystemPrompt,
   buildAutoSuggestPlanModeSystemPrompt,
   readAutoSuggestPlanModeSetting,
   PLAN_SUGGEST_QUESTION_ID,
@@ -813,8 +829,16 @@ export default function planCommand(pi: ExtensionAPI) {
     if (!actionSelection) return;
 
     if (actionSelection.includes(APPROVE_LABEL)) {
-      // Steer the second question — handle in the next tool_result cycle
-      pi.sendUserMessage(buildApprovalModeInstructions(), { deliverAs: "steer" });
+      const executionMode = approvalSelectionToExecutionMode(permissionValues[0]) ?? {
+        permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
+        executeWithSubagent: false,
+      };
+      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);
       return;
     }
 
@@ -831,9 +855,14 @@ export default function planCommand(pi: ExtensionAPI) {
     }
 
     if (actionSelection.includes(REVISE_LABEL)) {
+      const requestedChanges = getAnswerNote(actionAnswer);
       enablePlanMode(pi, ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined, {
         approvalStatus: "revising",
       });
+      pi.sendUserMessage(
+        buildRevisionSteeringMessage(state.latestPlanPath ?? "the latest plan", requestedChanges),
+        { deliverAs: "steer" },
+      );
     }
   });