@janvitos/pi-plan-build 0.1.27 → 0.1.30

package/README.md

@@ -74,7 +74,7 @@ When planning is complete, `plan_exit` displays the entire persisted plan and as
 2. start a clean linked implementation session; or
 3. stay in Plan mode.
 
-Selecting **Start fresh and implement** stops the current run and automatically dispatches `/build-fresh`. Pi 0.84.2 or newer is required for extension command dispatch from an injected user message. The command creates a linked child session, copies the approved plan to its canonical plan file, switches it to Build, and starts implementation without transferring the planning conversation.
+Selecting **Start fresh and implement** stops the current run and automatically dispatches `/build-fresh`. Pi 0.84.2 or newer is required for extension command dispatch from an injected user message. The command creates a linked child session, copies the approved plan to its canonical plan file, preserves the model and thinking level selected for the action, switches it to Build, and starts implementation without transferring the planning conversation.
 
 Selecting **Stay in Plan mode**, or pressing Escape while the approval dialog is open, displays:
 
@@ -111,7 +111,7 @@ npm test
 npm pack --dry-run
 ```
 
-The tests cover state decoding, safe plan paths, mutation restrictions, deferred transitions, mode and provider rendering, session-based prompt history restoration, complete plan rendering, approval decisions, stop behavior, fresh-session handoff content, and question formatting.
+The tests cover state decoding, safe plan paths, mutation restrictions, deferred transitions, mode and provider rendering, session-based prompt history restoration, complete plan rendering, approval decisions, stop behavior, fresh-session settings and handoff content, and question formatting.
 
 ### Publishing
 

package/index.ts

@@ -14,10 +14,12 @@ import {
 import {
 	applyManualSelection,
 	buildFreshImplementationHandoff,
+	buildFreshImplementationRequest,
 	buildPlanExitFreshResult,
 	buildPlanExitStayResult,
 	buildPlanReviewMessage,
 	classifyPlanExitChoice,
+	type FreshImplementationRequest,
 	decodeModeState,
 	extractPromptHistory,
 	formatFooterCwd,
@@ -73,7 +75,7 @@ export default function planBuildModes(pi: ExtensionAPI): void {
 	let toolsBeforeModes: string[] = [];
 	let currentContext: ExtensionContext | undefined;
 	let requestEditorRender: (() => void) | undefined;
-	let freshImplementationPlan: string | undefined;
+	let freshImplementationRequest: FreshImplementationRequest | undefined;
 
 	pi.registerFlag("plan", {
 		description: "Start in Plan mode",
@@ -160,28 +162,47 @@ export default function planBuildModes(pi: ExtensionAPI): void {
 	pi.registerCommand("build-fresh", {
 		description: "Start a clean linked session and implement the plan selected in plan_exit",
 		handler: async (_args, ctx) => {
-			const plan = freshImplementationPlan;
-			if (!plan) {
+			const request = freshImplementationRequest;
+			if (!request) {
 				ctx.ui.notify("No fresh implementation is pending. Choose ‘Start fresh and implement’ from plan_exit first.", "warning");
 				return;
 			}
 			if (selectedMode !== "plan") {
-				freshImplementationPlan = undefined;
+				freshImplementationRequest = undefined;
 				ctx.ui.notify("Fresh implementation is no longer available because Plan mode is not active.", "warning");
 				return;
 			}
 			if (ctx.mode === "print" || ctx.mode === "json") {
 				throw new Error("Fresh implementation requires TUI or RPC mode");
 			}
-			if (!ctx.model) {
+			if (!request.model) {
 				ctx.ui.notify("Cannot start implementation because no model is selected.", "warning");
 				return;
 			}
+			const currentModel = ctx.model;
+			const implementationModel = ctx.modelRegistry.find(request.model.provider, request.model.id)
+				?? (currentModel?.provider === request.model.provider && currentModel.id === request.model.id ? currentModel : undefined);
+			if (!implementationModel) {
+				ctx.ui.notify(`Cannot start implementation because ${request.model.provider}/${request.model.id} is unavailable.`, "warning");
+				return;
+			}
+			try {
+				const modelSelected = await pi.setModel(implementationModel);
+				if (modelSelected === false) {
+					ctx.ui.notify(`Cannot start implementation because no API key is available for ${request.model.provider}/${request.model.id}.`, "warning");
+					return;
+				}
+				pi.setThinkingLevel(request.thinkingLevel);
+			} catch (error: unknown) {
+				const detail = error instanceof Error ? error.message : String(error);
+				ctx.ui.notify(`Cannot start implementation with ${request.model.provider}/${request.model.id}: ${detail}`, "warning");
+				return;
+			}
 
-			freshImplementationPlan = undefined;
+			freshImplementationRequest = undefined;
 			const parentSession = ctx.sessionManager.getSessionFile();
 			const sourceTools = [...toolsBeforeModes];
-			const handoff = buildFreshImplementationHandoff(plan);
+			const handoff = buildFreshImplementationHandoff(request.plan);
 			let destinationPlanPath = "";
 			let setupError: string | undefined;
 			let kickoffError: string | undefined;
@@ -195,7 +216,9 @@ export default function planBuildModes(pi: ExtensionAPI): void {
 								sessionManager.getSessionId(),
 							);
 							await fs.promises.mkdir(path.dirname(destinationPlanPath), { recursive: true });
-							await fs.promises.writeFile(destinationPlanPath, plan, "utf8");
+							await fs.promises.writeFile(destinationPlanPath, request.plan, "utf8");
+							sessionManager.appendModelChange(request.model.provider, request.model.id);
+							sessionManager.appendThinkingLevelChange(request.thinkingLevel);
 							sessionManager.appendCustomEntry(STATE_TYPE, {
 								version: 1,
 								selectedMode: "build",
@@ -232,11 +255,11 @@ export default function planBuildModes(pi: ExtensionAPI): void {
 					},
 				});
 				if (result.cancelled) {
-					freshImplementationPlan = plan;
+					freshImplementationRequest = request;
 					ctx.ui.notify("Fresh implementation cancelled; the source plan remains available.", "info");
 				}
 			} catch (error: unknown) {
-				freshImplementationPlan = plan;
+				freshImplementationRequest = request;
 				const detail = error instanceof Error ? error.message : String(error);
 				try {
 					ctx.ui.notify(`Unable to start a fresh implementation session: ${detail}`, "error");
@@ -296,19 +319,23 @@ export default function planBuildModes(pi: ExtensionAPI): void {
 			));
 			const decision = classifyPlanExitChoice(selection.choice);
 			if (decision === "stay") {
-				freshImplementationPlan = undefined;
+				freshImplementationRequest = undefined;
 				pi.appendEntry(MODE_NOTICE_ENTRY_TYPE, { message: PLAN_EXIT_STAY_ACKNOWLEDGEMENT });
 				return buildPlanExitStayResult(planPath, selection.cancelled);
 			}
 			if (decision === "implement-fresh") {
-				freshImplementationPlan = plan;
+				freshImplementationRequest = buildFreshImplementationRequest(
+					plan,
+					ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined,
+					pi.getThinkingLevel(),
+				);
 				pi.sendUserMessage("/build-fresh", {
 					deliverAs: "followUp",
 					expandPromptTemplates: true,
 				});
 				return buildPlanExitFreshResult(planPath);
 			}
-			freshImplementationPlan = undefined;
+			freshImplementationRequest = undefined;
 			await selectMode("build", ctx, "tool");
 			return {
 				content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@janvitos/pi-plan-build",
-  "version": "0.1.27",
+  "version": "0.1.30",
   "description": "Plan safely, approve explicitly, then implement here or in a clean session.",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --experimental-strip-types --test utils.test.ts",
+    "test": "node --experimental-strip-types --test utils.test.ts question-ui.test.ts",
     "prepublishOnly": "npm test"
   },
   "peerDependencies": {

package/question-ui.ts

@@ -22,6 +22,16 @@ export const QuestionParameters = Type.Object({
 
 export type QuestionAnswer = QuestionAnswerData;
 
+const QUESTION_NOTICE_ENTRY_TYPE = "pi-plan-build-question-notice";
+const QUESTION_CANCELLED_MESSAGE = "You chose not to answer the question(s). Awaiting your instructions.";
+
+class QuestionCancelledError extends Error {
+	constructor() {
+		super("User cancelled the question");
+		this.name = "QuestionCancelledError";
+	}
+}
+
 async function askOne(
 	ctx: any,
 	prompt: {
@@ -31,6 +41,7 @@ async function askOne(
 		multiple?: boolean;
 		custom?: boolean;
 	},
+	signal: AbortSignal | undefined,
 ): Promise<QuestionAnswer> {
 	const allowCustom = prompt.custom !== false;
 	const labels = prompt.options.map((option) =>
@@ -41,11 +52,11 @@ async function askOne(
 
 	if (!prompt.multiple) {
 		const choices = [...labels, ...(allowCustom ? ["Type your own answer"] : [])];
-		const choice = await ctx.ui.select(`${prompt.header}: ${prompt.question}`, choices);
-		if (!choice) throw new Error("User cancelled the question");
+		const choice = await ctx.ui.select(`${prompt.header}: ${prompt.question}`, choices, { signal });
+		if (!choice) throw new QuestionCancelledError();
 		if (allowCustom && choice === "Type your own answer") {
-			const custom = await ctx.ui.input(prompt.header, prompt.question);
-			if (!custom?.trim()) throw new Error("User cancelled the question");
+			const custom = await ctx.ui.input(prompt.header, prompt.question, { signal });
+			if (!custom?.trim()) throw new QuestionCancelledError();
 			selected.push(custom.trim());
 			usedCustom = true;
 		} else {
@@ -59,11 +70,11 @@ async function askOne(
 				...(allowCustom ? ["Add a custom answer"] : []),
 				...(selected.length ? [`Done (${selected.join(", ")})`] : []),
 			];
-			const choice = await ctx.ui.select(`${prompt.header}: ${prompt.question}`, choices);
-			if (!choice) throw new Error("User cancelled the question");
+			const choice = await ctx.ui.select(`${prompt.header}: ${prompt.question}`, choices, { signal });
+			if (!choice) throw new QuestionCancelledError();
 			if (choice.startsWith("Done (")) break;
 			if (choice === "Add a custom answer") {
-				const custom = await ctx.ui.input(prompt.header, prompt.question);
+				const custom = await ctx.ui.input(prompt.header, prompt.question, { signal });
 				if (custom?.trim()) {
 					selected.push(custom.trim());
 					usedCustom = true;
@@ -81,17 +92,31 @@ async function askOne(
 }
 
 export function registerQuestionTool(pi: ExtensionAPI): void {
+	pi.registerEntryRenderer<{ message: string }>(QUESTION_NOTICE_ENTRY_TYPE, (entry, _options, theme) => {
+		const message = typeof entry.data?.message === "string" ? entry.data.message : QUESTION_CANCELLED_MESSAGE;
+		return new Text(theme.fg("warning", message), 0, 0);
+	});
 	pi.registerTool({
 		name: "question",
 		label: "Question",
 		description: `Use this tool when you need to ask the user questions during execution. This allows you to gather preferences, clarify ambiguous instructions, get implementation decisions, or offer choices. When custom is enabled (default), do not add an Other option yourself. Put the recommended option first and suffix its label with "(Recommended)".`,
 		parameters: QuestionParameters,
 		executionMode: "sequential",
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			if (!ctx.hasUI) throw new Error("The question tool requires an interactive TUI or RPC client");
 			if (params.questions.length === 0) throw new Error("At least one question is required");
 			const answers: QuestionAnswer[] = [];
-			for (const prompt of params.questions) answers.push(await askOne(ctx, prompt));
+			try {
+				for (const prompt of params.questions) answers.push(await askOne(ctx, prompt, signal));
+			} catch (error: unknown) {
+				if (!(error instanceof QuestionCancelledError)) throw error;
+				pi.appendEntry(QUESTION_NOTICE_ENTRY_TYPE, { message: QUESTION_CANCELLED_MESSAGE });
+				return {
+					content: [{ type: "text", text: QUESTION_CANCELLED_MESSAGE }],
+					details: { cancelled: true },
+					terminate: true,
+				};
+			}
 			const formatted = formatQuestionAnswers(answers);
 			return {
 				content: [{ type: "text", text: `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.` }],
@@ -103,7 +128,8 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
 			return new Text(theme.fg("toolTitle", theme.bold(`question (${count})`)), 0, 0);
 		},
 		renderResult(result, _options, theme) {
-			const details = result.details as { answers?: QuestionAnswer[] } | undefined;
+			const details = result.details as { answers?: QuestionAnswer[]; cancelled?: boolean } | undefined;
+			if (details?.cancelled) return new Text(theme.fg("warning", "Question(s) skipped"), 0, 0);
 			if (!details?.answers) return new Text(theme.fg("warning", "Question cancelled"), 0, 0);
 			return new Text(details.answers.map((a) => `${theme.fg("success", "✓")} ${a.header}: ${a.answers.join(", ")}`).join("\n"), 0, 0);
 		},

package/utils.ts

@@ -174,6 +174,20 @@ export function buildPlanExitFreshResult(planPath: string) {
 	};
 }
 
+export interface FreshImplementationRequest {
+	plan: string;
+	model?: { provider: string; id: string };
+	thinkingLevel: string;
+}
+
+export function buildFreshImplementationRequest(
+	plan: string,
+	model: { provider: string; id: string } | undefined,
+	thinkingLevel: string,
+): FreshImplementationRequest {
+	return { plan, model, thinkingLevel };
+}
+
 export function buildFreshImplementationHandoff(plan: string): string {
 	return `Plan mode is now disabled. Full tool access is restored. Implement this approved plan now:\n\n${plan}`;
 }