@bacnh85/pi-plan 0.1.1 → 0.1.3

package/README.md

@@ -2,10 +2,11 @@
 
 Pi extension that adds a lightweight plan mode inspired by Codex and Claude Code:
 
-- Toggle plan mode with `/plan`, `/plan on`, `/plan off`, or `Ctrl+Alt+P`.
-- Pick separate thinking/reasoning levels for planning and normal execution with `/plan levels`.
+- Toggle plan mode with `/plan` or `Ctrl+Alt+P`.
+- Remembers separate thinking/reasoning levels for planning and normal execution across sessions based on the active mode when you change Pi's reasoning level.
 - Keeps planning read-only by disabling built-in `edit`/`write` and blocking destructive shell commands.
 - Provides a `write_plan` tool so the agent writes reviewable Markdown plans into `.agents/plans/` in the current workspace.
+- Provides an `ask_plan_question` tool so the agent can ask selection-style clarifying questions during planning, with an option for free-form user input.
 - Prompts after a plan is written so you can approve execution, approve only, keep planning, or refine with feedback.
 
 ## Install
@@ -39,29 +40,38 @@ pi --plan
 | Command / shortcut | Description |
 | --- | --- |
 | `/plan` | Toggle plan mode. |
-| `/plan on` / `/plan off` | Explicitly enter or exit plan mode. |
-| `/plan levels` | Select planning and normal/execution thinking levels. |
-| `/plan status` | Show current mode, thinking levels, and last plan file. |
-| `/plan high` | Set the plan-mode thinking level directly (`off`, `minimal`, `low`, `medium`, `high`, `xhigh`). |
 | `Ctrl+Alt+P` | Toggle plan mode. |
 
 ## Workflow
 
 1. Enter plan mode.
 2. Ask pi to research the task and propose an implementation.
-3. The model explores read-only context and calls `write_plan`.
-4. The plan is saved under `.agents/plans/<timestamp>-<title>.md`.
-5. Choose one of the approval options:
-   - **Approve and execute**: exits plan mode, restores tools, applies normal thinking level, and sends a follow-up execution prompt.
+3. The model explores read-only context. If a consequential decision remains ambiguous, it can call `ask_plan_question` so you can choose an option or type your own answer.
+4. The model calls `write_plan`.
+5. The plan is saved under `.agents/plans/<timestamp>-<title>.md`.
+6. Choose one of the approval options:
+   - **Execute in current session**: exits plan mode, restores tools, applies normal thinking level, shows current context usage in the option label, and sends a follow-up execution prompt.
+   - **Execute in new session**: exits plan mode and prepares a fresh session that uses the saved Markdown plan file as the handoff artifact.
    - **Approve only**: exits plan mode without starting work.
    - **Keep planning**: remains in plan mode.
    - **Refine with feedback**: sends your feedback as a follow-up planning prompt.
 
+Agents should ask blocking, user-answerable planning questions with `ask_plan_question` before finalizing a plan. Final plans may still list non-blocking uncertainties or implementation-time checks, but should not leave consequential user decisions unresolved.
+
+## Reasoning levels
+
+pi-plan remembers two reasoning levels:
+
+- Change Pi's active reasoning level while plan mode is active to update the planning level.
+- Change Pi's active reasoning level in normal or execution mode to update the normal/execution level.
+
+The remembered levels are restored when switching modes and across independent or resumed sessions. pi-plan stores only these non-sensitive preferences under your user Pi agent directory.
+
 ## Design notes
 
 Research findings used for this extension:
 
-- Pi has no built-in plan mode by design, but extensions can implement it with commands, shortcuts, tool gating, status widgets, and prompt injection.
+- Pi has no built-in plan mode by design, but extensions can implement it with commands, shortcuts, tools, tool gating, and prompt injection.
 - Claude Code plan mode emphasizes read-only exploration, writing a Markdown plan, and an approval flow before edits.
 - Codex guidance recommends plan mode for complex or ambiguous tasks and using higher reasoning levels for harder planning/debugging work.
 

package/index.ts

@@ -1,14 +1,18 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isToolCallEventType, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 
 const STATUS_KEY = "pi-plan";
 const PLAN_DIR = path.join(".agents", "plans");
 const PLAN_TOOL = "write_plan";
+const PLAN_QUESTION_TOOL = "ask_plan_question";
+const PLAN_EXECUTE_COMMAND = "plan-execute";
+const PREFERENCES_FILE = path.join(os.homedir(), ".pi", "agent", "pi-plan", "preferences.json");
 const PLAN_MODE_DISABLED_TOOLS = new Set(["edit", "write"]);
-const DEFAULT_PLAN_TOOLS = ["read", "bash", "grep", "find", "ls", PLAN_TOOL];
+const DEFAULT_PLAN_TOOLS = ["read", "bash", "grep", "find", "ls", PLAN_TOOL, PLAN_QUESTION_TOOL];
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 
 type ThinkingLevel = (typeof THINKING_LEVELS)[number];
@@ -25,12 +29,29 @@ interface PlanState {
 	lastPlanStatus?: PlanStatus;
 }
 
+interface PlanPreferences {
+	version: 1;
+	planThinking: ThinkingLevel;
+	normalThinking: ThinkingLevel;
+}
+
 interface WritePlanParams {
 	title: string;
 	content: string;
 	status?: PlanStatus;
 }
 
+interface PlanQuestionOption {
+	label: string;
+	description?: string;
+}
+
+interface PlanQuestionParams {
+	question: string;
+	options: PlanQuestionOption[];
+	allowOther?: boolean;
+}
+
 const DESTRUCTIVE_BASH_PATTERNS = [
 	/\brm\b/i,
 	/\brmdir\b/i,
@@ -90,6 +111,43 @@ function relativeToCwd(cwd: string, absolutePath: string): string {
 	return path.relative(cwd, absolutePath).split(path.sep).join("/");
 }
 
+function formatContextUsage(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	if (!usage || usage.percent === null) return "context usage unknown";
+	const percent = `${Math.round(usage.percent)}% context used`;
+	if (usage.tokens === null) return percent;
+	return `${percent} (${Math.round(usage.tokens / 1000)}k / ${Math.round(usage.contextWindow / 1000)}k tokens)`;
+}
+
+function buildExecutionPrompt(relativePlan: string, mode: "current" | "new"): string {
+	const prefix = mode === "new" ? "This is a fresh session created from an approved pi-plan. " : "";
+	return `${prefix}Execute the approved plan in ${relativePlan}. Read the plan file if needed, keep the implementation scoped to the plan, update the plan if reality differs materially, and run the verification described there.`;
+}
+
+function hasOpenQuestionWarning(content: string): boolean {
+	return /(^|\n)#{1,6}\s+.*open questions?.*\n[\s\S]*\?/i.test(content);
+}
+
+async function loadPreferences(): Promise<PlanPreferences | undefined> {
+	try {
+		const raw = await readFile(PREFERENCES_FILE, "utf8");
+		const parsed = JSON.parse(raw) as Partial<PlanPreferences>;
+		const savedPlanThinking = parsed.planThinking;
+		const savedNormalThinking = parsed.normalThinking;
+		if (parsed.version !== 1 || !savedPlanThinking || !savedNormalThinking || !isThinkingLevel(savedPlanThinking) || !isThinkingLevel(savedNormalThinking)) return undefined;
+		return { version: 1, planThinking: savedPlanThinking, normalThinking: savedNormalThinking };
+	} catch {
+		return undefined;
+	}
+}
+
+async function savePreferences(preferences: PlanPreferences): Promise<void> {
+	await mkdir(path.dirname(PREFERENCES_FILE), { recursive: true });
+	const temporaryPath = `${PREFERENCES_FILE}.${process.pid}.tmp`;
+	await writeFile(temporaryPath, `${JSON.stringify(preferences, null, 2)}\n`, "utf8");
+	await rename(temporaryPath, PREFERENCES_FILE);
+}
+
 function isDestructiveBash(command: string): boolean {
 	return DESTRUCTIVE_BASH_PATTERNS.some((pattern) => pattern.test(command));
 }
@@ -103,6 +161,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	let lastPlanPath: string | undefined;
 	let lastPlanTitle: string | undefined;
 	let lastPlanStatus: PlanStatus | undefined;
+	let applyingStoredThinking = false;
 
 	function setStatus(ctx: ExtensionContext): void {
 		if (planModeEnabled) {
@@ -116,17 +175,8 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	}
 
-	function setPlanWidget(ctx: ExtensionContext): void {
-		if (!planModeEnabled) {
-			ctx.ui.setWidget(STATUS_KEY, undefined);
-			return;
-		}
-		ctx.ui.setWidget(STATUS_KEY, [
-			ctx.ui.theme.fg("warning", "Plan mode: read-only exploration"),
-			`Plan file target: ${PLAN_DIR}/`,
-			`Plan thinking: ${planThinking}; normal thinking: ${normalThinking}`,
-			"Use write_plan when the plan is ready for approval.",
-		]);
+	function clearPlanWidget(ctx: ExtensionContext): void {
+		ctx.ui.setWidget(STATUS_KEY, undefined);
 	}
 
 	function persistState(): void {
@@ -142,6 +192,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		} satisfies PlanState);
 	}
 
+	function persistPreferences(): void {
+		void savePreferences({ version: 1, planThinking, normalThinking }).catch(() => undefined);
+	}
+
 	function enablePlanTools(): void {
 		const baseline = toolsBeforePlan ?? pi.getActiveTools();
 		toolsBeforePlan = baseline;
@@ -154,7 +208,24 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	}
 
 	function applyThinking(level: ThinkingLevel): void {
+		applyingStoredThinking = true;
 		pi.setThinkingLevel(level);
+		setTimeout(() => {
+			applyingStoredThinking = false;
+		}, 0);
+	}
+
+	function recordActiveThinkingLevel(level: ThinkingLevel, ctx: ExtensionContext): void {
+		if (planModeEnabled) {
+			if (planThinking === level) return;
+			planThinking = level;
+		} else {
+			if (normalThinking === level) return;
+			normalThinking = level;
+		}
+		setStatus(ctx);
+		persistState();
+		persistPreferences();
 	}
 
 	function enterPlanMode(ctx: ExtensionContext): void {
@@ -163,7 +234,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		enablePlanTools();
 		applyThinking(planThinking);
 		setStatus(ctx);
-		setPlanWidget(ctx);
+		clearPlanWidget(ctx);
 		persistState();
 		ctx.ui.notify(`Plan mode enabled. Thinking=${planThinking}. Plans will be written to ${PLAN_DIR}/`, "info");
 	}
@@ -174,47 +245,62 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		restoreTools();
 		if (restoreThinking) applyThinking(normalThinking);
 		setStatus(ctx);
-		setPlanWidget(ctx);
+		clearPlanWidget(ctx);
 		persistState();
 		ctx.ui.notify(`Plan mode disabled. Thinking=${pi.getThinkingLevel()}.`, "info");
 	}
 
-	async function chooseThinkingLevels(ctx: ExtensionContext): Promise<void> {
-		const plan = await ctx.ui.select("Plan mode reasoning level", [...THINKING_LEVELS]);
-		if (plan && isThinkingLevel(plan)) planThinking = plan;
-		const normal = await ctx.ui.select("Normal/execution reasoning level", [...THINKING_LEVELS]);
-		if (normal && isThinkingLevel(normal)) normalThinking = normal;
-		if (planModeEnabled) applyThinking(planThinking);
-		else applyThinking(normalThinking);
+	async function handlePlanCommand(args: string, ctx: ExtensionContext): Promise<void> {
+		if (args.trim().length > 0) {
+			ctx.ui.notify("/plan does not take arguments; use /plan or Ctrl+Alt+P to toggle plan mode.", "warning");
+			return;
+		}
+		if (planModeEnabled) leavePlanMode(ctx);
+		else enterPlanMode(ctx);
+	}
+
+	function beginCurrentSessionExecution(ctx: ExtensionContext, relativePlan: string): void {
+		planModeEnabled = false;
+		executionMode = true;
+		lastPlanStatus = "approved";
+		restoreTools();
+		applyThinking(normalThinking);
 		setStatus(ctx);
-		setPlanWidget(ctx);
+		clearPlanWidget(ctx);
 		persistState();
-		ctx.ui.notify(`pi-plan levels: plan=${planThinking}, normal=${normalThinking}`, "info");
+		persistPreferences();
+		pi.sendUserMessage(buildExecutionPrompt(relativePlan, "current"), { deliverAs: "followUp" });
 	}
 
-	async function handlePlanCommand(args: string, ctx: ExtensionContext): Promise<void> {
-		const subcommand = args.trim();
-		if (subcommand === "levels") return chooseThinkingLevels(ctx);
-		if (subcommand === "on" || subcommand === "start") return enterPlanMode(ctx);
-		if (subcommand === "off" || subcommand === "stop") return leavePlanMode(ctx);
-		if (subcommand === "status") {
-			ctx.ui.notify(
-				[`Mode: ${planModeEnabled ? "planning" : executionMode ? "executing" : "normal"}`, `Plan thinking: ${planThinking}`, `Normal thinking: ${normalThinking}`, `Last plan: ${lastPlanPath ? relativeToCwd(ctx.cwd, lastPlanPath) : "none"}`].join("\n"),
-				"info",
-			);
-			return;
-		}
-		if (subcommand.length > 0 && isThinkingLevel(subcommand)) {
-			planThinking = subcommand;
-			if (planModeEnabled) applyThinking(planThinking);
-			setStatus(ctx);
-			setPlanWidget(ctx);
-			persistState();
-			ctx.ui.notify(`Plan thinking set to ${planThinking}`, "info");
+	async function beginNewSessionExecution(ctx: ExtensionCommandContext): Promise<void> {
+		if (!lastPlanPath) {
+			ctx.ui.notify("No approved plan is available to execute.", "error");
 			return;
 		}
-		if (planModeEnabled) leavePlanMode(ctx);
-		else enterPlanMode(ctx);
+		await ctx.waitForIdle();
+		const planPathToExecute = lastPlanPath;
+		const planTitleToExecute = lastPlanTitle;
+		const relativePlan = relativeToCwd(ctx.cwd, planPathToExecute);
+		const parentSession = ctx.sessionManager.getSessionFile();
+		const state: PlanState = {
+			enabled: false,
+			executing: true,
+			planThinking,
+			normalThinking,
+			lastPlanPath: planPathToExecute,
+			lastPlanTitle: planTitleToExecute,
+			lastPlanStatus: "approved",
+		};
+		const result = await ctx.newSession({
+			parentSession,
+			setup: async (sessionManager) => {
+				sessionManager.appendCustomEntry("pi-plan", state);
+			},
+			withSession: async (replacementCtx) => {
+				await replacementCtx.sendUserMessage(buildExecutionPrompt(relativePlan, "new"));
+			},
+		});
+		if (result.cancelled) ctx.ui.notify("New-session execution cancelled.", "info");
 	}
 
 	pi.registerFlag("plan", {
@@ -228,7 +314,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		label: "Write Plan",
 		description: `Write or replace the current implementation plan as Markdown under ${PLAN_DIR}/. Use in plan mode when the plan is ready for user review.`,
 		promptSnippet: `Write the implementation plan to ${PLAN_DIR}/ as a Markdown file for user review`,
-		promptGuidelines: [`Use ${PLAN_TOOL} in plan mode after repository exploration; do not use edit/write for implementation until the user approves the plan.`],
+		promptGuidelines: [
+			`Use ${PLAN_TOOL} in plan mode after repository exploration; do not use edit/write for implementation until the user approves the plan.`,
+			`Do not call ${PLAN_TOOL} while blocking user-answerable questions remain; use ${PLAN_QUESTION_TOOL} first.`,
+		],
 		parameters: Type.Object({
 			title: Type.String({ description: "Short human-readable title for the plan" }),
 			content: Type.String({ description: "Complete Markdown plan content" }),
@@ -246,22 +335,107 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 			lastPlanTitle = typedParams.title.trim() || "Plan";
 			lastPlanStatus = isPlanStatus(typedParams.status) ? typedParams.status : "draft";
 			persistState();
+			const warning = hasOpenQuestionWarning(content)
+				? ` If the plan contains blocking user-answerable open questions, call ${PLAN_QUESTION_TOOL} before requesting approval.`
+				: "";
 			return {
-				content: [{ type: "text", text: `Plan written to ${relativeToCwd(ctx.cwd, destination)}. Ask the user to approve, refine, or keep planning.` }],
+				content: [{ type: "text", text: `Plan written to ${relativeToCwd(ctx.cwd, destination)}. If no blocking user-answerable questions remain, ask the user to approve, refine, execute in current session, execute in a new session, or keep planning.${warning}` }],
 				details: { path: destination, title: lastPlanTitle, status: lastPlanStatus },
 			};
 		},
 	});
 
-	pi.registerCommand("plan", {
-		description: "Toggle pi-plan mode; subcommands: on, off, levels, status, or a thinking level",
-		getArgumentCompletions: (prefix) => {
-			const values = ["on", "off", "levels", "status", ...THINKING_LEVELS].filter((value) => value.startsWith(prefix));
-			return values.length ? values.map((value) => ({ label: value, value })) : null;
+	pi.registerTool({
+		name: PLAN_QUESTION_TOOL,
+		label: "Ask Plan Question",
+		description: "Ask the user a consequential planning question with selectable options and optional free-form input.",
+		promptSnippet: "Ask the user a concise planning question with 2-4 concrete options when an open decision materially affects the plan.",
+		promptGuidelines: [
+			"Use only after repository research leaves a consequential ambiguity that affects the plan.",
+			"Prefer 2-4 concrete options with short labels and useful descriptions.",
+			"Do not ask about details that can be discovered from the repository.",
+			"If the user already gave a preference, incorporate it instead of asking again.",
+		],
+		parameters: Type.Object({
+			question: Type.String({ description: "The planning question to ask the user" }),
+			options: Type.Array(
+				Type.Object({
+					label: Type.String({ description: "Short selectable option label" }),
+					description: Type.Optional(Type.String({ description: "Optional explanation shown with the option" })),
+				}),
+				{ description: "Concrete options for the user to choose from" },
+			),
+			allowOther: Type.Optional(Type.Boolean({ description: "Whether to allow a free-form user answer; defaults to true" })),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const typedParams = params as PlanQuestionParams;
+			const options = typedParams.options ?? [];
+			if (options.length === 0) {
+				return {
+					content: [{ type: "text", text: "Error: ask_plan_question requires at least one option." }],
+					details: { question: typedParams.question, answer: null },
+				};
+			}
+			if (!ctx.hasUI) {
+				return {
+					content: [{ type: "text", text: "UI is not available. Ask this planning question directly in chat and wait for the user's answer." }],
+					details: { question: typedParams.question, options, answer: null },
+				};
+			}
+
+			const allowOther = typedParams.allowOther !== false;
+			const labels = options.map((option) =>
+				option.description ? `${option.label} — ${option.description}` : option.label,
+			);
+			const otherLabel = "Other / type my answer";
+			const choice = await ctx.ui.select(typedParams.question, allowOther ? [...labels, otherLabel] : labels);
+			if (!choice) {
+				return {
+					content: [{ type: "text", text: "User cancelled the planning question." }],
+					details: { question: typedParams.question, options, answer: null, cancelled: true },
+				};
+			}
+
+			if (choice === otherLabel) {
+				const answer = (await ctx.ui.editor("Your answer", ""))?.trim();
+				if (!answer) {
+					return {
+						content: [{ type: "text", text: "User cancelled the planning question." }],
+						details: { question: typedParams.question, options, answer: null, cancelled: true },
+					};
+				}
+				return {
+					content: [{ type: "text", text: `User wrote: ${answer}` }],
+					details: { question: typedParams.question, options, answer, wasCustom: true },
+				};
+			}
+
+			const selectedIndex = labels.indexOf(choice);
+			const selected = options[selectedIndex];
+			const answer = selected?.label ?? choice;
+			return {
+				content: [{ type: "text", text: `User selected: ${answer}` }],
+				details: { question: typedParams.question, options, answer, selectedIndex: selectedIndex + 1, wasCustom: false },
+			};
 		},
+	});
+
+	pi.registerCommand("plan", {
+		description: "Toggle pi-plan mode",
 		handler: async (args, ctx) => handlePlanCommand(args, ctx),
 	});
 
+	pi.registerCommand(PLAN_EXECUTE_COMMAND, {
+		description: "Internal pi-plan execution bridge",
+		handler: async (args, ctx) => {
+			if (args.trim() !== "new") {
+				ctx.ui.notify(`Usage: /${PLAN_EXECUTE_COMMAND} new`, "warning");
+				return;
+			}
+			await beginNewSessionExecution(ctx);
+		},
+	});
+
 	pi.registerShortcut("ctrl+alt+p", {
 		description: "Toggle pi-plan mode",
 		handler: async (ctx) => {
@@ -271,27 +445,41 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		const preferences = await loadPreferences();
 		const entries = ctx.sessionManager.getEntries();
 		const saved = entries
 			.filter((entry: { type: string; customType?: string }) => entry.type === "custom" && entry.customType === "pi-plan")
 			.pop() as { data?: PlanState } | undefined;
+		if (preferences) {
+			planThinking = preferences.planThinking;
+			normalThinking = preferences.normalThinking;
+		}
 		if (saved?.data) {
 			planModeEnabled = saved.data.enabled ?? planModeEnabled;
 			executionMode = saved.data.executing ?? executionMode;
-			planThinking = saved.data.planThinking ?? planThinking;
-			normalThinking = saved.data.normalThinking ?? normalThinking;
+			if (!preferences && isThinkingLevel(saved.data.planThinking)) planThinking = saved.data.planThinking;
+			if (!preferences && isThinkingLevel(saved.data.normalThinking)) normalThinking = saved.data.normalThinking;
 			toolsBeforePlan = saved.data.toolsBeforePlan ?? toolsBeforePlan;
 			lastPlanPath = saved.data.lastPlanPath ?? lastPlanPath;
 			lastPlanTitle = saved.data.lastPlanTitle ?? lastPlanTitle;
 			lastPlanStatus = saved.data.lastPlanStatus ?? lastPlanStatus;
 		}
+		if (!preferences) persistPreferences();
 		if (pi.getFlag("plan") === true) planModeEnabled = true;
 		if (planModeEnabled) {
 			enablePlanTools();
 			applyThinking(planThinking);
+		} else if (executionMode) {
+			applyThinking(normalThinking);
 		}
 		setStatus(ctx);
-		setPlanWidget(ctx);
+		clearPlanWidget(ctx);
+	});
+
+	pi.on("thinking_level_select", async (event, ctx) => {
+		if (applyingStoredThinking) return;
+		if (!isThinkingLevel(event.level)) return;
+		recordActiveThinkingLevel(event.level, ctx);
 	});
 
 	pi.on("tool_call", async (event) => {
@@ -311,7 +499,7 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 			return {
 				message: {
 					customType: "pi-plan-context",
-					content: `[PI-PLAN MODE ACTIVE]\nYou are in read-only planning mode. Research the codebase and produce a reviewable implementation plan before making changes.\n\nRules:\n- Do not edit source files, configs, lockfiles, or git state.\n- You may read files, search, inspect git state, and run read-only shell commands.\n- Ask concise clarifying questions if requirements are ambiguous.\n- When the plan is ready, call ${PLAN_TOOL} with a complete Markdown plan.\n- The plan file must live in ${PLAN_DIR}/. Current/next plan path: ${relativePlan}\n\nPlan content should include:\n1. Goal and assumptions.\n2. Key findings with durable file/symbol paths.\n3. Proposed implementation steps.\n4. Verification plan.\n5. Risks, open questions, and rejected alternatives if relevant.`,
+					content: `[PI-PLAN MODE ACTIVE]\nYou are in read-only planning mode. Research the codebase and produce a reviewable implementation plan before making changes.\n\nRules:\n- Do not edit source files, configs, lockfiles, or git state.\n- You may read files, search, inspect git state, and run read-only shell commands.\n- Ask concise clarifying questions if requirements are ambiguous. Use ${PLAN_QUESTION_TOOL} for consequential open decisions with 2-4 clear options and an Other/user-opinion path.\n- Do not ask about details you can discover from repository evidence. If the user already gave an opinion, incorporate it instead of asking again.\n- Before calling ${PLAN_TOOL}, if any consequential, user-answerable decision remains, call ${PLAN_QUESTION_TOOL} and wait for the answer. Do not place blocking user decisions in the final plan as open questions.\n- When the plan is ready, call ${PLAN_TOOL} with a complete Markdown plan.\n- The plan file must live in ${PLAN_DIR}/. Current/next plan path: ${relativePlan}\n\nPlan content should include:\n1. Goal and assumptions.\n2. Key findings with durable file/symbol paths.\n3. Proposed implementation steps.\n4. Verification plan.\n5. Risks, non-blocking open questions, and rejected alternatives if relevant.`,
 					display: false,
 				},
 			};
@@ -337,22 +525,29 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	pi.on("agent_end", async (_event, ctx) => {
 		if (!planModeEnabled || !lastPlanPath || !ctx.hasUI) return;
 		const relativePlan = relativeToCwd(ctx.cwd, lastPlanPath);
+		const currentSessionChoice = `Execute in current session (${formatContextUsage(ctx)})`;
+		const newSessionChoice = "Execute in new session (fresh context)";
 		const choice = await ctx.ui.select(`Plan written: ${relativePlan}`, [
-			"Approve and execute",
+			currentSessionChoice,
+			newSessionChoice,
 			"Approve only (exit plan mode)",
 			"Keep planning",
 			"Refine with feedback",
 		]);
-		if (choice === "Approve and execute") {
+		if (choice === currentSessionChoice) {
+			beginCurrentSessionExecution(ctx, relativePlan);
+		} else if (choice === newSessionChoice) {
 			planModeEnabled = false;
-			executionMode = true;
+			executionMode = false;
 			lastPlanStatus = "approved";
 			restoreTools();
 			applyThinking(normalThinking);
 			setStatus(ctx);
-			setPlanWidget(ctx);
+			clearPlanWidget(ctx);
 			persistState();
-			pi.sendUserMessage(`Execute the approved plan in ${relativePlan}. Keep the implementation scoped to the plan, update the plan if reality differs materially, and run the verification described there.`, { deliverAs: "followUp" });
+			persistPreferences();
+			ctx.ui.setEditorText(`/${PLAN_EXECUTE_COMMAND} new`);
+			ctx.ui.notify("Press Enter to start execution in a new session.", "info");
 		} else if (choice === "Approve only (exit plan mode)") {
 			lastPlanStatus = "approved";
 			leavePlanMode(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-plan",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Pi extension that adds a plan mode with workspace markdown plans and thinking-level presets.",
   "license": "MIT",
   "publishConfig": {