pi-interview 0.5.5 → 0.6.0

package/README.md

@@ -38,6 +38,7 @@ Restart pi to load the extension.
 - **Session Status Bar**: Shows project path, git branch, and session ID for identification
 - **Image Support**: Drag & drop anywhere on question, file picker, paste image or path
 - **Path Normalization**: Handles shell-escaped paths (`\ `) and macOS screenshot filenames (narrow no-break space before AM/PM)
+- **Generate & Review Options**: Single/multi-select questions show "✦ Generate more" (appends new choices) and "↻ Review options" (validates and rewrites existing choices) buttons powered by an LLM
 - **Themes**: Built-in default + optional light/dark + custom theme CSS
 
 ## How It Works
@@ -287,6 +288,7 @@ Settings in `~/.pi/agent/settings.json`:
     "port": 19847,
     "snapshotDir": "~/.pi/interview-snapshots/",
     "autoSaveOnSubmit": true,
+    "generateModel": "anthropic/claude-haiku-4-5",
     "theme": {
       "mode": "auto",
       "name": "default",
@@ -306,6 +308,8 @@ Settings in `~/.pi/agent/settings.json`:
 
 **Port setting**: Set a fixed `port` (e.g., `19847`) to use a consistent port across sessions.
 
+**Generate model**: `generateModel` sets the model for the generate/review option actions (e.g., `"anthropic/claude-haiku-4-5"`). Defaults to the agent's current model, then falls back to a cheap available model. If an explicitly configured generate model fails at request time and the current session is using a different model, interview retries once with the current session model.
+
 **Theme notes:**
 - `mode`: `dark` (default), `light`, or `auto` (follows OS unless overridden)
 - `name`: built-in themes are `default` and `tufte`

package/form/script.js

@@ -1232,7 +1232,8 @@
     
     if (event.key === 'Tab') {
       const inAttachArea = document.activeElement?.closest('.attach-inline');
-      if (inAttachArea) return;
+      const inGenerateArea = document.activeElement?.closest('.generate-more');
+      if (inAttachArea || inGenerateArea) return;
       
       event.preventDefault();
       
@@ -1287,6 +1288,9 @@
         if (document.activeElement?.closest('.attach-inline')) {
           return;
         }
+        if (document.activeElement?.closest('.generate-more')) {
+          return;
+        }
         event.preventDefault();
         const option = options[nav.optionIndex];
         if (option) {
@@ -1388,6 +1392,210 @@
     }
   }
 
+  function createGenerateMoreUI(question, list) {
+    if (!data.canGenerate) return null;
+
+    const container = document.createElement("div");
+    container.className = "generate-more";
+
+    const btnRow = document.createElement("div");
+    btnRow.className = "generate-more-row";
+
+    const addBtn = document.createElement("button");
+    addBtn.type = "button";
+    addBtn.className = "generate-more-btn";
+    addBtn.innerHTML = '<span class="generate-more-icon">✦</span> Generate more';
+
+    const reviewBtn = document.createElement("button");
+    reviewBtn.type = "button";
+    reviewBtn.className = "generate-more-btn";
+    reviewBtn.innerHTML = '<span class="generate-more-icon">↻</span> Review options';
+
+    const status = document.createElement("div");
+    status.className = "generate-more-status hidden";
+
+    btnRow.appendChild(addBtn);
+    btnRow.appendChild(reviewBtn);
+    container.appendChild(btnRow);
+    container.appendChild(status);
+
+    let generating = false;
+    let abortController = null;
+    let statusTimer = null;
+
+    function clearStatus() {
+      if (statusTimer !== null) {
+        clearTimeout(statusTimer);
+        statusTimer = null;
+      }
+      status.classList.add("hidden");
+      status.classList.remove("error");
+    }
+
+    function showStatus(message, timeoutMs, isError = false) {
+      if (statusTimer !== null) {
+        clearTimeout(statusTimer);
+        statusTimer = null;
+      }
+
+      status.textContent = message;
+      status.classList.remove("hidden");
+      status.classList.toggle("error", isError);
+
+      if (timeoutMs == null) {
+        return;
+      }
+
+      statusTimer = setTimeout(() => {
+        status.classList.add("hidden");
+        statusTimer = null;
+      }, timeoutMs);
+    }
+
+    function getExistingOptions() {
+      const inputs = list.querySelectorAll(
+        'input[name="' + escapeSelector(question.id) + '"]'
+      );
+      return Array.from(inputs)
+        .map((input) => input.value)
+        .filter((v) => v && v !== "__other__");
+    }
+
+    async function runGenerate(btn, mode) {
+      if (generating) {
+        if (abortController) abortController.abort();
+        return;
+      }
+
+      generating = true;
+      const icon = btn.querySelector(".generate-more-icon").textContent;
+      btn.innerHTML = '<span class="generate-more-icon">' + icon + '</span> Cancel';
+      btn.classList.add("loading");
+      addBtn.disabled = true;
+      reviewBtn.disabled = true;
+      btn.disabled = false;
+      clearStatus();
+
+      abortController = new AbortController();
+      const existingOptions = getExistingOptions();
+
+      try {
+        const response = await fetch("/generate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            token: sessionToken,
+            questionId: question.id,
+            existingOptions,
+            mode,
+          }),
+          signal: abortController.signal,
+        });
+
+        const result = await response.json();
+        if (!result.ok) throw new Error(result.error || "Generation failed");
+        if (!Array.isArray(result.options) || result.options.length === 0) {
+          throw new Error("No options generated");
+        }
+
+        if (mode === "review") {
+          const seen = new Set();
+          const revisedOptions = result.options.filter((option) => {
+            const key = option.toLowerCase().trim();
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+          if (revisedOptions.length === 0) {
+            throw new Error("No valid options returned for review");
+          }
+
+          list
+            .querySelectorAll('.option-item:not(.option-other):not(.done-item)')
+            .forEach((el) => el.remove());
+          revisedOptions.forEach((optionText, i) => {
+            const optionEl = createGeneratedOption(question, optionText, i);
+            list.insertBefore(optionEl, container);
+          });
+          if (question.type === "multi") updateDoneState(question.id);
+          debounceSave();
+          showStatus(
+            revisedOptions.length + " option" + (revisedOptions.length > 1 ? "s" : "") + " revised",
+            2500,
+          );
+        } else {
+          const existingSet = new Set(existingOptions.map((o) => o.toLowerCase().trim()));
+          const seen = new Set();
+          const newOptions = result.options.filter((o) => {
+            const key = o.toLowerCase().trim();
+            if (existingSet.has(key) || seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+
+          if (newOptions.length === 0) {
+            showStatus("All generated options already exist", 3000);
+          } else {
+            newOptions.forEach((optionText, i) => {
+              const optionEl = createGeneratedOption(question, optionText, i);
+              list.insertBefore(optionEl, container);
+            });
+            showStatus(
+              newOptions.length + " option" + (newOptions.length > 1 ? "s" : "") + " added",
+              2500,
+            );
+          }
+        }
+        refreshCountdown();
+      } catch (err) {
+        if (!(err instanceof Error && err.name === "AbortError")) {
+          showStatus(err instanceof Error ? err.message : "Generation failed", null, true);
+        }
+      } finally {
+        generating = false;
+        addBtn.innerHTML = '<span class="generate-more-icon">✦</span> Generate more';
+        reviewBtn.innerHTML = '<span class="generate-more-icon">↻</span> Review options';
+        addBtn.classList.remove("loading");
+        reviewBtn.classList.remove("loading");
+        addBtn.disabled = false;
+        reviewBtn.disabled = false;
+        abortController = null;
+      }
+    }
+
+    addBtn.addEventListener("click", () => runGenerate(addBtn, "add"));
+    reviewBtn.addEventListener("click", () => runGenerate(reviewBtn, "review"));
+
+    return container;
+  }
+
+  function createGeneratedOption(question, optionText, animIndex) {
+    const label = document.createElement("label");
+    label.className = "option-item generated";
+    label.style.animationDelay = (animIndex * 0.08) + "s";
+
+    const input = document.createElement("input");
+    input.type = question.type === "single" ? "radio" : "checkbox";
+    input.name = question.id;
+    input.value = optionText;
+    input.setAttribute("tabindex", "-1");
+
+    input.addEventListener("change", () => {
+      debounceSave();
+      if (question.type === "multi") {
+        updateDoneState(question.id);
+      }
+    });
+
+    const text = document.createElement("span");
+    text.textContent = optionText;
+
+    label.appendChild(input);
+    label.appendChild(text);
+
+    return label;
+  }
+
   function createQuestionCard(question, index, badgeNumber) {
     const card = document.createElement("section");
     card.className = "question-card";
@@ -1523,6 +1731,8 @@
         list.appendChild(label);
       });
 
+      const generateMoreEl = createGenerateMoreUI(question, list);
+      if (generateMoreEl) list.appendChild(generateMoreEl);
 
       const otherLabel = document.createElement("label");
       otherLabel.className = "option-item option-other";

package/form/styles.css

@@ -1710,6 +1710,106 @@ button {
   background: color-mix(in srgb, var(--card-accent, var(--accent)) 4%, var(--bg-elevated));
 }
 
+/* Generate more options */
+.generate-more {
+  margin: 4px 0 2px;
+}
+
+.generate-more-row {
+  display: flex;
+  gap: 6px;
+}
+
+.generate-more-btn {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 10px 14px;
+  border: 1px dashed var(--border-muted);
+  border-radius: 8px;
+  background: transparent;
+  color: var(--fg-dim);
+  font-family: var(--font-body);
+  font-size: var(--font-size-option);
+  cursor: pointer;
+  transition: border-color 150ms ease, color 150ms ease, background 150ms ease;
+}
+
+.generate-more-btn:hover {
+  border-color: color-mix(in srgb, var(--card-accent, var(--accent)) 50%, transparent);
+  color: var(--card-accent, var(--accent));
+  background: color-mix(in srgb, var(--card-accent, var(--accent)) 5%, transparent);
+}
+
+.generate-more-btn:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--focus-ring);
+}
+
+.generate-more-icon {
+  font-size: 14px;
+  line-height: 1;
+}
+
+@keyframes generate-shimmer {
+  0% { background-position: 200% center; }
+  100% { background-position: -200% center; }
+}
+
+@keyframes generate-spin {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
+.generate-more-btn.loading {
+  border-style: solid;
+  border-color: color-mix(in srgb, var(--card-accent, var(--accent)) 30%, transparent);
+  color: var(--card-accent, var(--accent));
+  background: linear-gradient(
+    90deg,
+    transparent 0%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 8%, transparent) 40%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 15%, transparent) 50%,
+    color-mix(in srgb, var(--card-accent, var(--accent)) 8%, transparent) 60%,
+    transparent 100%
+  );
+  background-size: 200% 100%;
+  animation: generate-shimmer 2s ease-in-out infinite;
+}
+
+.generate-more-btn.loading .generate-more-icon {
+  animation: generate-spin 1.5s linear infinite;
+  display: inline-block;
+}
+
+.generate-more-btn:disabled:not(.loading) {
+  opacity: 0.4;
+  pointer-events: none;
+}
+
+.generate-more-status {
+  margin-top: 8px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--fg-muted);
+}
+
+.generate-more-status.error {
+  color: var(--error);
+}
+
+/* Generated option entrance */
+@keyframes option-slide-in {
+  from { opacity: 0; transform: translateY(8px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.option-item.generated {
+  animation: option-slide-in 0.25s ease-out backwards;
+}
+
 /* Side-by-side layout */
 .question-side-layout {
   display: grid;

package/index.ts

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@mariozechner/pi-ai";
+import { StringEnum, complete, type Api, type AssistantMessage, type Model } from "@mariozechner/pi-ai";
 import { Text } from "@mariozechner/pi-tui";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import * as path from "node:path";
@@ -8,7 +8,7 @@ import * as fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import { execSync, execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
-import { startInterviewServer, getActiveSessions, type ResponseItem } from "./server.js";
+import { startInterviewServer, getActiveSessions, type ResponseItem, type InterviewServerCallbacks } from "./server.js";
 import { validateQuestions, sanitizeLLMJSON, type QuestionsFile } from "./schema.js";
 import { loadSettings, type InterviewThemeSettings } from "./settings.js";
 
@@ -232,6 +232,163 @@ function loadQuestions(questionsInput: string, cwd: string): SavedQuestionsFile
 	return validateQuestions(data);
 }
 
+interface GenerateModelCandidate {
+	provider: string;
+	id: string;
+}
+
+const PREFERRED_GENERATE_MODELS = [
+	"anthropic/claude-haiku-4-5",
+	"google/gemini-2.5-flash",
+	"openai/gpt-4.1-mini",
+];
+
+const GENERATE_OPTIONS_SYSTEM_PROMPT =
+	"You generate interview answer options. Return only a JSON array of strings. Do not include explanations or markdown.";
+
+function formatModelRef(model: GenerateModelCandidate): string {
+	return `${model.provider}/${model.id}`;
+}
+
+function findModelByRef<T extends GenerateModelCandidate>(models: T[], modelRef: string): T | null {
+	for (const model of models) {
+		if (formatModelRef(model) === modelRef) {
+			return model;
+		}
+	}
+	return null;
+}
+
+export function selectGenerateModels<T extends GenerateModelCandidate>(
+	configuredModel: T | null,
+	currentModel: T | null,
+	availableModels: T[],
+): { primary: T | null; fallback: T | null } {
+	if (configuredModel) {
+		if (!currentModel || formatModelRef(currentModel) === formatModelRef(configuredModel)) {
+			return { primary: configuredModel, fallback: null };
+		}
+		return { primary: configuredModel, fallback: currentModel };
+	}
+
+	if (currentModel) {
+		return { primary: currentModel, fallback: null };
+	}
+
+	for (const modelRef of PREFERRED_GENERATE_MODELS) {
+		const preferredModel = findModelByRef(availableModels, modelRef);
+		if (preferredModel) {
+			return { primary: preferredModel, fallback: null };
+		}
+	}
+
+	return { primary: availableModels[0] ?? null, fallback: null };
+}
+
+export function extractGenerateResponseText(
+	modelRef: string,
+	response: Pick<AssistantMessage, "content" | "stopReason" | "errorMessage">,
+): string {
+	if (response.stopReason === "aborted") {
+		throw new Error("Aborted");
+	}
+	if (response.stopReason === "error") {
+		throw new Error(response.errorMessage ? `${modelRef}: ${response.errorMessage}` : `${modelRef} failed`);
+	}
+
+	const text = response.content
+		.filter((part): part is { type: "text"; text: string } => part.type === "text")
+		.map((part) => part.text)
+		.join("")
+		.trim();
+	if (!text) {
+		throw new Error(`${modelRef} returned no text response`);
+	}
+	return text;
+}
+
+export function extractJSONArray(text: string): string {
+	const start = text.indexOf("[");
+	if (start === -1) return text;
+
+	let depth = 0;
+	let inString = false;
+	let escaping = false;
+
+	for (let i = start; i < text.length; i++) {
+		const char = text[i];
+
+		if (inString) {
+			if (escaping) {
+				escaping = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaping = true;
+				continue;
+			}
+			if (char === '"') {
+				inString = false;
+			}
+			continue;
+		}
+
+		if (char === '"') {
+			inString = true;
+			continue;
+		}
+		if (char === "[") {
+			depth++;
+			continue;
+		}
+		if (char !== "]") {
+			continue;
+		}
+
+		depth--;
+		if (depth === 0) {
+			return text.slice(start, i + 1);
+		}
+	}
+
+	return text;
+}
+
+export function createGenerateContext(prompt: string) {
+	return {
+		systemPrompt: GENERATE_OPTIONS_SYSTEM_PROMPT,
+		messages: [{
+			role: "user" as const,
+			content: [{ type: "text" as const, text: prompt }],
+			timestamp: Date.now(),
+		}],
+	};
+}
+
+export function parseGeneratedOptions(text: string): string[] {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(extractJSONArray(text));
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse generated options: ${detail}`);
+	}
+	if (!Array.isArray(parsed)) {
+		throw new Error("Expected array of options");
+	}
+
+	const options = parsed
+		.filter(
+			(item: unknown): item is string =>
+				typeof item === "string" && item.trim().length > 0,
+		)
+		.map((option: string) => option.trim());
+	if (options.length === 0) {
+		throw new Error("No valid options generated");
+	}
+	return options;
+}
+
 function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile {
 	// Extract JSON from <script id="pi-interview-data">
 	const match = html.match(/<script[^>]+id=["']pi-interview-data["'][^>]*>([\s\S]*?)<\/script>/i);
@@ -395,6 +552,32 @@ export default function (pi: ExtensionAPI) {
 			const themeConfig = mergeThemeConfig(settings.theme, theme, ctx.cwd);
 			const questionsData = loadQuestions(questions, ctx.cwd);
 
+			let configuredGenerateModel: Model<Api> | null = null;
+			if (settings.generateModel) {
+				const slashIdx = settings.generateModel.indexOf("/");
+				if (slashIdx > 0) {
+					configuredGenerateModel = ctx.modelRegistry.find(
+						settings.generateModel.slice(0, slashIdx),
+						settings.generateModel.slice(slashIdx + 1),
+					);
+				}
+			}
+
+			let availableGenerateModels: Model<Api>[] = [];
+			if (!configuredGenerateModel && !ctx.model) {
+				try {
+					availableGenerateModels = ctx.modelRegistry.getAvailable();
+				} catch {
+					// Leave generation disabled when model discovery is unavailable.
+				}
+			}
+
+			const { primary: generateModel, fallback: fallbackGenerateModel } = selectGenerateModels(
+				configuredGenerateModel,
+				ctx.model ?? null,
+				availableGenerateModels,
+			);
+
 			// Expand ~ in snapshotDir if present
 			const snapshotDir = settings.snapshotDir
 				? expandHome(settings.snapshotDir)
@@ -469,6 +652,89 @@ export default function (pi: ExtensionAPI) {
 				};
 				signal?.addEventListener("abort", handleAbort, { once: true });
 
+				let onGenerate: InterviewServerCallbacks["onGenerate"];
+				if (generateModel) {
+					const generateOptions = async (model: Model<Api>, prompt: string, generateSignal: AbortSignal) => {
+						const modelRef = formatModelRef(model);
+						const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+						if (!auth.ok) throw new Error(`${modelRef}: ${auth.error}`);
+						if (!auth.apiKey) throw new Error(`No API key for ${modelRef}`);
+
+						const response = await complete(
+							model,
+							createGenerateContext(prompt),
+							{ apiKey: auth.apiKey, headers: auth.headers, signal: generateSignal },
+						);
+
+						return parseGeneratedOptions(extractGenerateResponseText(modelRef, response));
+					};
+
+					onGenerate = async (questionId, existingOptions, generateSignal, mode) => {
+						const question = questionsData.questions.find((q) => q.id === questionId);
+						if (!question) throw new Error(`Unknown question: ${questionId}`);
+
+						const existingList = existingOptions.length > 0
+							? existingOptions.map((option) => `- ${option}`).join("\n")
+							: "(none)";
+
+						let prompt: string;
+						if (mode === "review") {
+							let recommended = "";
+							if (question.recommended) {
+								const value = Array.isArray(question.recommended)
+									? question.recommended.join(", ")
+									: question.recommended;
+								recommended = `\nRecommended: ${value}`;
+							}
+							prompt = [
+								"Review these options for the question below. Fix any issues: incorrect options, missing obvious choices, poor wording, redundancy.",
+								"Return ONLY a JSON array of the corrected option strings. Keep good options as-is, fix bad ones, add missing ones, remove bad ones.",
+								"",
+								questionsData.title ? `Interview: ${questionsData.title}` : null,
+								`Question: ${question.question}`,
+								question.context ? `Context: ${question.context}` : null,
+								recommended || null,
+								"",
+								"Current options:",
+								existingList,
+								"",
+								'Format: ["Option A", "Option B", "Option C"]',
+							].filter((line) => line !== null).join("\n");
+						} else {
+							prompt = [
+								"Generate 3 new, distinct options for this question.",
+								"Return ONLY a JSON array of short option strings. No explanation, no markdown.",
+								"",
+								`Question: ${question.question}`,
+								question.context ? `Context: ${question.context}` : null,
+								"",
+								"Existing options (do NOT repeat):",
+								existingList,
+								"",
+								'Format: ["Option A", "Option B", "Option C"]',
+							].filter((line) => line !== null).join("\n");
+						}
+
+						let options: string[];
+						try {
+							options = await generateOptions(generateModel, prompt, generateSignal);
+						} catch (err) {
+							if (!fallbackGenerateModel || generateSignal.aborted) {
+								throw err;
+							}
+							try {
+								options = await generateOptions(fallbackGenerateModel, prompt, generateSignal);
+							} catch (fallbackErr) {
+								const primaryMessage = err instanceof Error ? err.message : String(err);
+								const fallbackMessage = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+								throw new Error(`${primaryMessage}. Fallback failed: ${fallbackMessage}`);
+							}
+						}
+
+						return { options };
+					};
+				}
+
 				startInterviewServer(
 					{
 						questions: questionsData,
@@ -482,6 +748,7 @@ export default function (pi: ExtensionAPI) {
 						snapshotDir,
 						autoSaveOnSubmit: settings.autoSaveOnSubmit ?? true,
 						savedAnswers: questionsData.savedAnswers,
+						canGenerate: generateModel !== null,
 					},
 					{
 						onSubmit: (responses) => finish("completed", responses),
@@ -489,6 +756,7 @@ export default function (pi: ExtensionAPI) {
 							reason === "timeout"
 								? finish("timeout", partialResponses ?? [])
 								: finish("cancelled", partialResponses ?? [], reason),
+						onGenerate,
 					}
 				)
 					.then(async (handle) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-interview",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "Interactive interview form extension for pi coding agent",
   "author": "Nico Bailon",
   "license": "MIT",

package/server.ts

@@ -196,11 +196,18 @@ export interface InterviewServerOptions {
 	snapshotDir?: string;
 	autoSaveOnSubmit?: boolean;
 	savedAnswers?: ResponseItem[];
+	canGenerate?: boolean;
 }
 
 export interface InterviewServerCallbacks {
 	onSubmit: (responses: ResponseItem[]) => void;
 	onCancel: (reason?: "timeout" | "user" | "stale", partialResponses?: ResponseItem[]) => void;
+	onGenerate?: (
+		questionId: string,
+		existingOptions: string[],
+		signal: AbortSignal,
+		mode: "add" | "review",
+	) => Promise<{ options: string[] }>;
 }
 
 export interface InterviewServerHandle {
@@ -882,6 +889,7 @@ export async function startInterviewServer(
 					},
 					savedAnswers: options.savedAnswers,
 					autoSaveOnSubmit: options.autoSaveOnSubmit ?? true,
+					canGenerate: options.canGenerate ?? false,
 				});
 				const html = TEMPLATE
 					.replace("<!-- __CDN_SCRIPTS__ -->", cdnScripts)
@@ -1283,6 +1291,68 @@ export async function startInterviewServer(
 				return;
 			}
 
+			if (method === "POST" && url.pathname === "/generate") {
+				const body = await parseBodyOrRespond();
+				if (!body) return;
+				if (!validateTokenBody(body, sessionToken, res)) return;
+				if (completed) {
+					sendJson(res, 409, { ok: false, error: "Session closed" });
+					return;
+				}
+
+				if (!callbacks.onGenerate) {
+					sendJson(res, 501, { ok: false, error: "Generation not available" });
+					return;
+				}
+
+				const payload = body as {
+					questionId?: string;
+					existingOptions?: string[];
+					mode?: string;
+				};
+
+				if (typeof payload.questionId !== "string") {
+					sendJson(res, 400, { ok: false, error: "Missing questionId" });
+					return;
+				}
+
+				const question = questionById.get(payload.questionId);
+				if (!question || (question.type !== "single" && question.type !== "multi")) {
+					sendJson(res, 400, { ok: false, error: "Invalid question for generation" });
+					return;
+				}
+
+				const existingOptions = Array.isArray(payload.existingOptions)
+					? payload.existingOptions.filter((o): o is string => typeof o === "string")
+					: [];
+
+				const mode = payload.mode === "review" ? "review" : "add";
+
+				const controller = new AbortController();
+				res.on("close", () => {
+					if (!res.writableEnded) controller.abort();
+				});
+				touchHeartbeat();
+
+				try {
+					const result = await callbacks.onGenerate(
+						payload.questionId,
+						existingOptions,
+						controller.signal,
+						mode,
+					);
+					sendJson(res, 200, { ok: true, options: result.options });
+				} catch (err) {
+					if (controller.signal.aborted) {
+						sendJson(res, 409, { ok: false, error: "Request cancelled" });
+						return;
+					}
+					const message = err instanceof Error ? err.message : "Generation failed";
+					sendJson(res, 500, { ok: false, error: message });
+				}
+				return;
+			}
+
 			sendText(res, 404, "Not found");
 		} catch (err) {
 			const message = err instanceof Error ? err.message : "Server error";

package/settings.ts

@@ -19,6 +19,7 @@ export interface InterviewSettings {
 	theme?: InterviewThemeSettings;
 	snapshotDir?: string;      // Default: ~/.pi/interview-snapshots/
 	autoSaveOnSubmit?: boolean; // Default: true
+	generateModel?: string;    // e.g., "anthropic/claude-haiku-4-5"
 }
 
 export function loadSettings(): InterviewSettings {