pi-interview 0.6.0 → 0.6.2

package/README.md

@@ -38,7 +38,8 @@ 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
+- **Generate & Review Options**: Single/multi-select questions show "✦ Generate more" (appends new choices) and "↻ Review options" (reviews options and rewrites the question for clarity) buttons powered by an LLM
+- **Tool Discoverability (pi v0.59+)**: Registers a `promptSnippet` so `interview` remains eligible for inclusion in pi's default `Available tools` prompt section
 - **Themes**: Built-in default + optional light/dark + custom theme CSS
 
 ## How It Works
@@ -138,26 +139,26 @@ await interview({
 | `id` | string | Unique identifier |
 | `type` | string | `single`, `multi`, `text`, `image`, or `info` |
 | `question` | string | Question text |
-| `options` | string[] or object[] | Choices (required for single/multi). Can be strings or `{ label, code? }` objects |
+| `options` | string[] or object[] | Choices (required for single/multi). Can be strings or `{ label, content? }` objects |
 | `recommended` | string or string[] | Shows "Recommended" badge and pre-selects option(s) |
 | `conviction` | string | `"strong"` or `"slight"`. Slight opts out of pre-selection. Requires `recommended` |
 | `weight` | string | `"critical"` (prominent card) or `"minor"` (compact card) |
 | `context` | string | Help text shown below question |
-| `codeBlock` | object | Code block displayed below question text |
+| `content` | object | Content block displayed below question text (`lang: "md"|"markdown"` previews Markdown by default) |
 | `media` | object or object[] | Media content: image, chart, mermaid, table, or html |
 
-### Code Blocks
+### Content Blocks
 
-Questions and options can include code blocks for displaying code snippets, diffs, and file references.
+Questions and options can include `content` blocks for code snippets, diffs, and Markdown.
 
-**Question-level code block** (displayed above options):
+**Question-level code content** (displayed above options):
 ```json
 {
   "id": "review",
   "type": "single",
   "question": "Review this implementation",
-  "codeBlock": {
-    "code": "function add(a, b) {\n  return a + b;\n}",
+  "content": {
+    "source": "function add(a, b) {\n  return a + b;\n}",
     "lang": "ts",
     "file": "src/math.ts",
     "lines": "10-12",
@@ -167,44 +168,59 @@ Questions and options can include code blocks for displaying code snippets, diff
 }
 ```
 
-**Options with code blocks**:
+**Options with content blocks**:
 ```json
 {
   "options": [
     {
       "label": "Use async/await",
-      "code": { "code": "const data = await fetch(url);", "lang": "ts" }
+      "content": { "source": "const data = await fetch(url);", "lang": "ts" }
     },
     {
       "label": "Use promises",
-      "code": { "code": "fetch(url).then(data => ...);", "lang": "ts" }
+      "content": { "source": "fetch(url).then(data => ...);", "lang": "ts" }
     },
     "Keep current implementation"
   ]
 }
 ```
 
-**Diff display** (set `lang: "diff"`):
+**Diff display** (`lang: "diff"`):
 ```json
 {
-  "codeBlock": {
-    "code": "--- a/file.ts\n+++ b/file.ts\n@@ -1,3 +1,4 @@\n const x = 1;\n+const y = 2;\n const z = 3;",
+  "content": {
+    "source": "--- a/file.ts\n+++ b/file.ts\n@@ -1,3 +1,4 @@\n const x = 1;\n+const y = 2;\n const z = 3;",
     "lang": "diff",
     "file": "src/file.ts"
   }
 }
 ```
 
-| CodeBlock Field | Type | Description |
-|-----------------|------|-------------|
-| `code` | string | The code content (required) |
-| `lang` | string | Language for display (e.g., "ts", "diff") |
-| `file` | string | File path to display in header |
-| `lines` | string | Line range to display (e.g., "10-25") |
-| `highlights` | number[] | Line numbers to highlight |
-| `title` | string | Optional title above code |
+**Markdown preview by default** (`lang: "md"` or `"markdown"`):
+```json
+{
+  "content": {
+    "source": "# Release notes\n\n- Added preview mode\n- Fixed wrapping",
+    "lang": "md"
+  }
+}
+```
 
-Line numbers are shown when `file` or `lines` is specified. Diff syntax (`+`/`-` lines) is automatically styled when `lang` is "diff".
+Set `showSource: true` on Markdown content to show raw Markdown instead of preview.
+
+| Content Field | Type | Description |
+|---------------|------|-------------|
+| `source` | string | Content text (required) |
+| `lang` | string | Language hint (e.g., `ts`, `diff`, `md`) |
+| `file` | string | File path shown in the header |
+| `lines` | string | Line range shown in the header (code content only) |
+| `highlights` | number[] | Line highlights (code content only) |
+| `title` | string | Optional title above content |
+| `showSource` | boolean | Markdown only: `true` forces raw source instead of preview |
+
+Rules:
+- `lang: "md"` or `"markdown"`: preview by default, `showSource: true` shows raw source.
+- Any other `lang`: renders as raw source; `showSource` is not allowed.
 
 ### Info Panels
 

package/form/script.js

@@ -380,12 +380,16 @@
     el.textContent = text || "";
   }
 
-  function renderLightMarkdown(text) {
-    if (!text) return "";
-    let html = text
+  function escapeHtml(text) {
+    return String(text || "")
       .replace(/&/g, "&")
       .replace(/</g, "&lt;")
       .replace(/>/g, "&gt;");
+  }
+
+  function renderLightMarkdown(text) {
+    if (!text) return "";
+    let html = escapeHtml(text);
     html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
     html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
     html = html.replace(/\n/g, "<br>");
@@ -393,6 +397,118 @@
     return html;
   }
 
+  function isMarkdownLang(lang) {
+    if (typeof lang !== "string") return false;
+    const normalized = lang.trim().toLowerCase();
+    return normalized === "md" || normalized === "markdown";
+  }
+
+  function renderMarkdownPreviewFallback(markdown) {
+    const lines = String(markdown || "").replace(/\r\n?/g, "\n").split("\n");
+    const html = [];
+    const paragraph = [];
+    let listType = null;
+    let inFence = false;
+    let fenceLang = "";
+    let fenceLines = [];
+
+    const flushParagraph = () => {
+      if (paragraph.length === 0) return;
+      html.push(`<p>${renderLightMarkdown(paragraph.join(" "))}</p>`);
+      paragraph.length = 0;
+    };
+
+    const closeList = () => {
+      if (!listType) return;
+      html.push(listType === "ol" ? "</ol>" : "</ul>");
+      listType = null;
+    };
+
+    for (const rawLine of lines) {
+      const line = rawLine ?? "";
+
+      if (inFence) {
+        if (/^```/.test(line.trim())) {
+          html.push(`<pre class="markdown-fence"><code${fenceLang ? ` data-lang="${escapeHtml(fenceLang)}"` : ""}>${escapeHtml(fenceLines.join("\n"))}</code></pre>`);
+          inFence = false;
+          fenceLang = "";
+          fenceLines = [];
+        } else {
+          fenceLines.push(line);
+        }
+        continue;
+      }
+
+      const fenceStart = line.match(/^```\s*([^\s`]*)\s*$/);
+      if (fenceStart) {
+        flushParagraph();
+        closeList();
+        inFence = true;
+        fenceLang = fenceStart[1] || "";
+        fenceLines = [];
+        continue;
+      }
+
+      if (!line.trim()) {
+        flushParagraph();
+        closeList();
+        continue;
+      }
+
+      const headingMatch = line.match(/^\s{0,3}(#{1,6})\s+(.+)$/);
+      if (headingMatch) {
+        flushParagraph();
+        closeList();
+        const level = headingMatch[1].length;
+        html.push(`<h${level}>${renderLightMarkdown(headingMatch[2].trim())}</h${level}>`);
+        continue;
+      }
+
+      const quoteMatch = line.match(/^>\s?(.*)$/);
+      if (quoteMatch) {
+        flushParagraph();
+        closeList();
+        html.push(`<blockquote><p>${renderLightMarkdown(quoteMatch[1])}</p></blockquote>`);
+        continue;
+      }
+
+      const orderedMatch = line.match(/^\s*\d+\.\s+(.+)$/);
+      if (orderedMatch) {
+        flushParagraph();
+        if (listType !== "ol") {
+          closeList();
+          html.push("<ol>");
+          listType = "ol";
+        }
+        html.push(`<li>${renderLightMarkdown(orderedMatch[1])}</li>`);
+        continue;
+      }
+
+      const unorderedMatch = line.match(/^\s*[-*]\s+(.+)$/);
+      if (unorderedMatch) {
+        flushParagraph();
+        if (listType !== "ul") {
+          closeList();
+          html.push("<ul>");
+          listType = "ul";
+        }
+        html.push(`<li>${renderLightMarkdown(unorderedMatch[1])}</li>`);
+        continue;
+      }
+
+      closeList();
+      paragraph.push(line.trim());
+    }
+
+    if (inFence) {
+      html.push(`<pre class="markdown-fence"><code${fenceLang ? ` data-lang="${escapeHtml(fenceLang)}"` : ""}>${escapeHtml(fenceLines.join("\n"))}</code></pre>`);
+    }
+
+    flushParagraph();
+    closeList();
+    return html.join("\n");
+  }
+
   function getOptionLabel(option) {
     return typeof option === "string" ? option : option.label;
   }
@@ -401,22 +517,43 @@
     return typeof option === "object" && option !== null && "label" in option;
   }
 
-  function renderCodeBlock(block) {
-    if (!block || !block.code) return null;
+  function syncRecommendations(question, options) {
+    if (!question.recommended) return;
 
+    if (question.type === "single") {
+      if (typeof question.recommended === "string" && options.includes(question.recommended)) {
+        return;
+      }
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+
+    if (question.type !== "multi") {
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+
+    const nextRecommended = (Array.isArray(question.recommended)
+      ? question.recommended
+      : [question.recommended]).filter((option) => options.includes(option));
+    if (nextRecommended.length === 0) {
+      delete question.recommended;
+      delete question.conviction;
+      return;
+    }
+    question.recommended = nextRecommended;
+  }
+
+  function renderContentBlock(block) {
+    if (!block || !block.source) return null;
+
+    const markdownPreview = isMarkdownLang(block.lang) && block.showSource !== true;
     const container = document.createElement("div");
     container.className = "code-block";
-
-    const showLineNumbers = !!block.file || !!block.lines;
-    const isDiff = block.lang === "diff";
-    const lines = block.code.split("\n");
-    const highlights = new Set(block.highlights || []);
-    
-    // Parse starting line number from lines prop (e.g., "10-16" -> 10, "42" -> 42)
-    let startLineNum = 1;
-    if (block.lines) {
-      const match = block.lines.match(/^(\d+)/);
-      if (match) startLineNum = parseInt(match[1], 10);
+    if (markdownPreview) {
+      container.classList.add("markdown-content-block");
     }
 
     if (block.file || block.lines || block.lang || block.title) {
@@ -454,6 +591,25 @@
       container.appendChild(header);
     }
 
+    if (markdownPreview) {
+      const preview = document.createElement("div");
+      preview.className = "markdown-preview";
+      preview.innerHTML = renderMarkdownPreviewFallback(block.source);
+      container.appendChild(preview);
+      return container;
+    }
+
+    const showLineNumbers = !!block.file || !!block.lines;
+    const isDiff = block.lang === "diff";
+    const lines = block.source.split("\n");
+    const highlights = new Set(block.highlights || []);
+
+    let startLineNum = 1;
+    if (block.lines) {
+      const match = block.lines.match(/^(\d+)/);
+      if (match) startLineNum = parseInt(match[1], 10);
+    }
+
     const pre = document.createElement("pre");
     const code = document.createElement("code");
 
@@ -497,7 +653,7 @@
 
       code.appendChild(linesContainer);
     } else {
-      code.textContent = block.code;
+      code.textContent = block.source;
     }
 
     pre.appendChild(code);
@@ -1394,6 +1550,7 @@
 
   function createGenerateMoreUI(question, list) {
     if (!data.canGenerate) return null;
+    if (question.options.some(isRichOption)) return null;
 
     const container = document.createElement("div");
     container.className = "generate-more";
@@ -1499,6 +1656,10 @@
         }
 
         if (mode === "review") {
+          if (typeof result.question !== "string" || !result.question.trim()) {
+            throw new Error("No revised question returned");
+          }
+
           const seen = new Set();
           const revisedOptions = result.options.filter((option) => {
             const key = option.toLowerCase().trim();
@@ -1510,6 +1671,14 @@
             throw new Error("No valid options returned for review");
           }
 
+          question.question = result.question.trim();
+          question.options = revisedOptions;
+          syncRecommendations(question, revisedOptions);
+          const title = list.closest('.question-card')?.querySelector('.question-title');
+          if (title) {
+            title.innerHTML = renderLightMarkdown(question.question);
+          }
+
           list
             .querySelectorAll('.option-item:not(.option-other):not(.done-item)')
             .forEach((el) => el.remove());
@@ -1520,7 +1689,7 @@
           if (question.type === "multi") updateDoneState(question.id);
           debounceSave();
           showStatus(
-            revisedOptions.length + " option" + (revisedOptions.length > 1 ? "s" : "") + " revised",
+            "Question updated and " + revisedOptions.length + " option" + (revisedOptions.length > 1 ? "s" : "") + " revised",
             2500,
           );
         } else {
@@ -1536,6 +1705,7 @@
           if (newOptions.length === 0) {
             showStatus("All generated options already exist", 3000);
           } else {
+            question.options = question.options.concat(newOptions);
             newOptions.forEach((optionText, i) => {
               const optionEl = createGeneratedOption(question, optionText, i);
               list.insertBefore(optionEl, container);
@@ -1633,11 +1803,11 @@
       card.appendChild(context);
     }
 
-    if (question.codeBlock) {
-      const codeBlockEl = renderCodeBlock(question.codeBlock);
-      if (codeBlockEl) {
-        codeBlockEl.classList.add("question-code-block");
-        card.appendChild(codeBlockEl);
+    if (question.content) {
+      const contentBlockEl = renderContentBlock(question.content);
+      if (contentBlockEl) {
+        contentBlockEl.classList.add("question-code-block");
+        card.appendChild(contentBlockEl);
       }
     }
 
@@ -1683,11 +1853,11 @@
 
       question.options.forEach((option, optionIndex) => {
         const optionLabel = getOptionLabel(option);
-        const optionCode = isRichOption(option) ? option.code : null;
+        const optionContent = isRichOption(option) ? option.content : null;
 
         const label = document.createElement("label");
         label.className = "option-item";
-        if (optionCode) {
+        if (optionContent) {
           label.classList.add("has-code");
         }
 
@@ -1721,10 +1891,10 @@
         label.appendChild(input);
         label.appendChild(text);
 
-        if (optionCode) {
-          const codeBlockEl = renderCodeBlock(optionCode);
-          if (codeBlockEl) {
-            label.appendChild(codeBlockEl);
+        if (optionContent) {
+          const contentBlockEl = renderContentBlock(optionContent);
+          if (contentBlockEl) {
+            label.appendChild(contentBlockEl);
           }
         }
 
@@ -2578,7 +2748,8 @@
       }
     } catch (err) {
       if (!submitted) {
-        showSaveError("Failed to save interview");
+        const message = err instanceof Error ? err.message : String(err);
+        showSaveError(`Failed to save interview: ${message}`);
       }
       return false;
     }
@@ -2659,7 +2830,8 @@
       if (isNetworkError(err)) {
         showSessionExpired();
       } else {
-        showGlobalError("Failed to submit responses.");
+        const message = err instanceof Error ? err.message : String(err);
+        showGlobalError(`Failed to submit responses: ${message}`);
         submitBtn.disabled = false;
       }
     }

package/form/styles.css

@@ -1391,8 +1391,11 @@ button {
 .code-block pre {
   margin: 0;
   padding: 0.75rem;
-  overflow-x: auto;
+  overflow-x: hidden;
   line-height: 1.5;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  word-break: break-word;
 }
 
 .code-block code {
@@ -1400,11 +1403,97 @@ button {
   font-size: var(--font-size-code);
   background: none;
   padding: 0;
+  white-space: inherit;
+  overflow-wrap: inherit;
+  word-break: inherit;
+}
+
+.markdown-content-block .code-block-header {
+  border-bottom: 0;
+}
+
+.markdown-preview {
+  padding: 0.875rem;
+  display: grid;
+  gap: 0.625rem;
+  color: var(--fg);
+  line-height: 1.6;
+  text-wrap: pretty;
+}
+
+.markdown-preview > * {
+  margin: 0;
+}
+
+.markdown-preview h1,
+.markdown-preview h2,
+.markdown-preview h3,
+.markdown-preview h4,
+.markdown-preview h5,
+.markdown-preview h6 {
+  font-family: var(--font-display);
+  line-height: 1.2;
+  text-wrap: balance;
+}
+
+.markdown-preview h1 { font-size: 1.2rem; }
+.markdown-preview h2 { font-size: 1.1rem; }
+.markdown-preview h3 { font-size: 1rem; }
+
+.markdown-preview ul,
+.markdown-preview ol {
+  margin: 0;
+  padding-left: 1.25rem;
+  display: grid;
+  gap: 0.35rem;
+}
+
+.markdown-preview blockquote {
+  margin: 0;
+  padding-left: 0.75rem;
+  border-left: 3px solid var(--accent-muted);
+  color: var(--fg-muted);
+}
+
+.markdown-preview pre {
+  margin: 0;
+  padding: 0.75rem;
+  border-radius: 6px;
+  background: color-mix(in srgb, var(--bg-body) 90%, transparent);
+  border: 1px solid var(--border-muted);
+  overflow-x: auto;
+}
+
+.markdown-preview pre code {
+  font-family: var(--font-mono);
+  font-size: var(--font-size-code);
+  white-space: pre;
+}
+
+.markdown-preview code {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  background: color-mix(in srgb, var(--bg-body) 80%, transparent);
+  padding: 0.1rem 0.3rem;
+  border-radius: 4px;
+}
+
+.markdown-preview a {
+  color: var(--accent);
+  text-underline-offset: 2px;
+}
+
+.markdown-preview p code,
+.markdown-preview li code,
+.markdown-preview blockquote code {
+  white-space: normal;
+  overflow-wrap: anywhere;
 }
 
 .code-block-lines-container {
   display: table;
-  min-width: 100%;
+  width: 100%;
+  table-layout: fixed;
 }
 
 .code-block-line {
@@ -1425,7 +1514,8 @@ button {
 
 .code-block-line-content {
   display: table-cell;
-  white-space: pre;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
   padding-right: 0.75rem;
 }
 

package/index.ts

@@ -246,6 +246,9 @@ const PREFERRED_GENERATE_MODELS = [
 const GENERATE_OPTIONS_SYSTEM_PROMPT =
 	"You generate interview answer options. Return only a JSON array of strings. Do not include explanations or markdown.";
 
+const REVIEW_QUESTION_SYSTEM_PROMPT =
+	"You review interview questions and answer options. Preserve intent. Return only JSON with a rewritten question string and an options array.";
+
 function formatModelRef(model: GenerateModelCandidate): string {
 	return `${model.provider}/${model.id}`;
 }
@@ -307,8 +310,8 @@ export function extractGenerateResponseText(
 	return text;
 }
 
-export function extractJSONArray(text: string): string {
-	const start = text.indexOf("[");
+function extractJSONBlock(text: string, openChar: "[" | "{", closeChar: "]" | "}"): string {
+	const start = text.indexOf(openChar);
 	if (start === -1) return text;
 
 	let depth = 0;
@@ -337,11 +340,11 @@ export function extractJSONArray(text: string): string {
 			inString = true;
 			continue;
 		}
-		if (char === "[") {
+		if (char === openChar) {
 			depth++;
 			continue;
 		}
-		if (char !== "]") {
+		if (char !== closeChar) {
 			continue;
 		}
 
@@ -354,9 +357,17 @@ export function extractJSONArray(text: string): string {
 	return text;
 }
 
-export function createGenerateContext(prompt: string) {
+export function extractJSONArray(text: string): string {
+	return extractJSONBlock(text, "[", "]");
+}
+
+function extractJSONObject(text: string): string {
+	return extractJSONBlock(text, "{", "}");
+}
+
+export function createGenerateContext(prompt: string, systemPrompt = GENERATE_OPTIONS_SYSTEM_PROMPT) {
 	return {
-		systemPrompt: GENERATE_OPTIONS_SYSTEM_PROMPT,
+		systemPrompt,
 		messages: [{
 			role: "user" as const,
 			content: [{ type: "text" as const, text: prompt }],
@@ -365,14 +376,7 @@ export function createGenerateContext(prompt: string) {
 	};
 }
 
-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}`);
-	}
+function normalizeGeneratedOptions(parsed: unknown): string[] {
 	if (!Array.isArray(parsed)) {
 		throw new Error("Expected array of options");
 	}
@@ -389,7 +393,41 @@ export function parseGeneratedOptions(text: string): string[] {
 	return options;
 }
 
-function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile {
+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}`);
+	}
+	return normalizeGeneratedOptions(parsed);
+}
+
+export function parseReviewedQuestion(text: string): { question: string; options: string[] } {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(extractJSONObject(text));
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse reviewed question: ${detail}`);
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		throw new Error("Expected reviewed question object");
+	}
+
+	const review = parsed as Record<string, unknown>;
+	if (typeof review.question !== "string" || !review.question.trim()) {
+		throw new Error("Reviewed question must include a non-empty question string");
+	}
+
+	return {
+		question: review.question.trim(),
+		options: normalizeGeneratedOptions(review.options),
+	};
+}
+
+export 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);
 	if (!match) {
@@ -406,11 +444,13 @@ function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile
 
 	const raw = data as Record<string, unknown>;
 	const validated = validateQuestions(data);
+	const questionTypeById = new Map(validated.questions.map((question) => [question.id, question.type]));
 
-	// Resolve relative image paths to absolute based on HTML file location
+	// Resolve relative image paths to absolute based on HTML file location.
+	// Only image-question values are treated as paths; text/single/multi values must stay literal.
 	const snapshotDir = path.dirname(filePath);
 	const savedAnswers = Array.isArray(raw.savedAnswers)
-		? resolveAnswerPaths(raw.savedAnswers as ResponseItem[], snapshotDir)
+		? resolveAnswerPaths(raw.savedAnswers as ResponseItem[], snapshotDir, questionTypeById)
 		: undefined;
 
 	// Validate savedFrom if present
@@ -436,26 +476,28 @@ function loadSavedInterview(html: string, filePath: string): SavedQuestionsFile
 	};
 }
 
-function resolveAnswerPaths(answers: ResponseItem[], baseDir: string): ResponseItem[] {
-	return answers.map((ans) => ({
-		...ans,
-		value: resolvePathValue(ans.value, baseDir),
-		attachments: ans.attachments?.map((p) => resolveImagePath(p, baseDir)),
-	}));
+function resolveAnswerPaths(
+	answers: ResponseItem[],
+	baseDir: string,
+	questionTypeById: Map<string, "single" | "multi" | "text" | "image" | "info">,
+): ResponseItem[] {
+	return answers.map((ans) => {
+		const questionType = questionTypeById.get(ans.id);
+		return {
+			...ans,
+			value: questionType === "image" ? resolvePathValue(ans.value, baseDir) : ans.value,
+			attachments: ans.attachments?.map((attachmentPath) => resolveImagePath(attachmentPath, baseDir)),
+		};
+	});
 }
 
 function resolveImagePath(p: string, baseDir: string): string {
 	if (!p) return p;
-	// Skip URLs
-	if (p.includes("://")) return p;
-	// Expand ~ first
+	// Skip URLs and data/file URIs
+	if (p.includes("://") || p.startsWith("data:") || p.startsWith("file:")) return p;
 	const expanded = expandHome(p);
-	// Don't resolve if already absolute (cross-platform check)
-	if (path.isAbsolute(expanded)) {
-		return expanded;
-	}
-	// Resolve relative path against snapshot directory
-	return path.join(baseDir, p);
+	if (path.isAbsolute(expanded)) return expanded;
+	return path.join(baseDir, expanded);
 }
 
 function resolvePathValue(value: string | string[], baseDir: string): string | string[] {
@@ -513,16 +555,18 @@ export default function (pi: ExtensionAPI) {
 			"Provides better UX than back-and-forth chat for structured input. " +
 			"Image responses and attachments are returned as file paths - use read tool directly to display them. " +
 			"Pass questions as inline JSON string directly (preferred) or as a path to a JSON file. " +
-			'Questions JSON format: { "title": "...", "description": "...", "questions": [{ "id": "q1", "type": "single|multi|text|image|info", "question": "...", "options": ["A", "B"], "codeBlock": { "code": "...", "lang": "ts" }, "media": { "type": "image|chart|mermaid|table|html", ... } }] }. ' +
-			"Options can be strings or objects: { label: string, code?: { code, lang?, file?, lines?, highlights? } }. " +
+			'Questions JSON format: { "title": "...", "description": "...", "questions": [{ "id": "q1", "type": "single|multi|text|image|info", "question": "...", "options": ["A", "B"], "content": { "source": "...", "lang": "ts" }, "media": { "type": "image|chart|mermaid|table|html", ... } }] }. ' +
+			"Options can be strings or objects: { label: string, content?: { source, lang?, file?, lines?, highlights?, title?, showSource? } }. " +
 			"Always set recommended with context explaining your reasoning. Recommended options show a 'Recommended' badge and are pre-selected for the user. " +
 			'Use conviction: "slight" when unsure (does NOT pre-select), conviction: "strong" when very confident (shows Recommended badge). ' +
 			"Omit conviction for normal recommendations (pre-selects). " +
 			'Use weight: "critical" for key decisions (visually prominent), weight: "minor" for low-stakes questions (compact card). ' +
 			"When questions have recommendations, set description to guide review (e.g., 'Review my suggestions and adjust as needed'). " +
-			"Questions can have a codeBlock field to display code above options. Types: single (radio), multi (checkbox), text (textarea), image (file upload), info (non-interactive). " +
+			"Questions can have a content field to display code or markdown above options. lang: \"md\" or \"markdown\" defaults to markdown preview unless showSource is true. Types: single (radio), multi (checkbox), text (textarea), image (file upload), info (non-interactive). " +
 			'Media blocks: { type: "image", src, alt, caption }, { type: "table", table: { headers, rows, highlights }, caption }, { type: "chart", chart: { type, data, options }, caption }, { type: "mermaid", mermaid: "graph LR\\n..." }, { type: "html", html }. ' +
 			"Info type is a non-interactive content panel for displaying context with media. Media position: above (default), below, side (two-column).",
+		promptSnippet:
+			"Gather structured user input through an interactive form for requirements, tradeoffs, or multi-dimensional decisions.",
 		parameters: InterviewParams,
 
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -669,6 +713,21 @@ export default function (pi: ExtensionAPI) {
 						return parseGeneratedOptions(extractGenerateResponseText(modelRef, response));
 					};
 
+					const reviewQuestion = 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, REVIEW_QUESTION_SYSTEM_PROMPT),
+							{ apiKey: auth.apiKey, headers: auth.headers, signal: generateSignal },
+						);
+
+						return parseReviewedQuestion(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}`);
@@ -687,18 +746,20 @@ export default function (pi: ExtensionAPI) {
 								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.",
+								"Review this interview question and its options.",
+								"Rewrite the question so it is easier to understand while preserving the original intent.",
+								"Review the options the same way you already would: keep good ones as-is, fix bad ones, add missing ones, and remove bad ones.",
+								"Return ONLY JSON in this format:",
+								'{"question":"Clearer question text","options":["Option A","Option B","Option C"]}',
 								"",
 								questionsData.title ? `Interview: ${questionsData.title}` : null,
+								questionsData.description ? `Interview context: ${questionsData.description}` : null,
 								`Question: ${question.question}`,
-								question.context ? `Context: ${question.context}` : null,
+								question.context ? `Question context: ${question.context}` : null,
 								recommended || null,
 								"",
 								"Current options:",
 								existingList,
-								"",
-								'Format: ["Option A", "Option B", "Option C"]',
 							].filter((line) => line !== null).join("\n");
 						} else {
 							prompt = [
@@ -715,6 +776,26 @@ export default function (pi: ExtensionAPI) {
 							].filter((line) => line !== null).join("\n");
 						}
 
+						if (mode === "review") {
+							let result: { question: string; options: string[] };
+							try {
+								result = await reviewQuestion(generateModel, prompt, generateSignal);
+							} catch (err) {
+								if (!fallbackGenerateModel || generateSignal.aborted) {
+									throw err;
+								}
+								try {
+									result = await reviewQuestion(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 result;
+						}
+
 						let options: string[];
 						try {
 							options = await generateOptions(generateModel, prompt, generateSignal);

package/package.json

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

package/schema.ts

@@ -1,15 +1,28 @@
-export interface CodeBlock {
-	code: string;
+export interface BaseContentBlock {
+	source: string;
 	lang?: string;
 	file?: string;
+	title?: string;
+}
+
+export interface MarkdownContentBlock extends BaseContentBlock {
+	lang: "md" | "markdown";
+	showSource?: boolean;
+	lines?: never;
+	highlights?: never;
+}
+
+export interface CodeContentBlock extends BaseContentBlock {
 	lines?: string;
 	highlights?: number[];
-	title?: string;
+	showSource?: never;
 }
 
+export type ContentBlock = MarkdownContentBlock | CodeContentBlock;
+
 export interface RichOption {
 	label: string;
-	code?: CodeBlock;
+	content?: ContentBlock;
 }
 
 export type OptionValue = string | RichOption;
@@ -44,7 +57,7 @@ export interface Question {
 	conviction?: "strong" | "slight";
 	weight?: "critical" | "minor";
 	context?: string;
-	codeBlock?: CodeBlock;
+	content?: ContentBlock;
 	media?: MediaBlock | MediaBlock[];
 }
 
@@ -127,34 +140,71 @@ const SCHEMA_EXAMPLE = `Expected format:
   ]
 }
 Valid types: single, multi, text, image, info
-Options: array of strings or objects with { label, code? }`;
+Options: array of strings or objects with { label, content? }`;
+
+function isMarkdownLang(lang: unknown): lang is "md" | "markdown" {
+	if (typeof lang !== "string") return false;
+	const normalized = lang.trim().toLowerCase();
+	return normalized === "md" || normalized === "markdown";
+}
 
-function validateCodeBlock(block: unknown, context: string): CodeBlock {
+function validateContentBlock(block: unknown, context: string): ContentBlock {
 	if (!block || typeof block !== "object") {
-		throw new Error(`${context}: codeBlock must be an object`);
+		throw new Error(`${context}: content must be an object`);
 	}
 	const b = block as Record<string, unknown>;
-	if (typeof b.code !== "string") {
-		throw new Error(`${context}: codeBlock.code must be a string`);
+	if (typeof b.source !== "string") {
+		throw new Error(`${context}: content.source must be a string`);
 	}
 	if (b.lang !== undefined && typeof b.lang !== "string") {
-		throw new Error(`${context}: codeBlock.lang must be a string`);
+		throw new Error(`${context}: content.lang must be a string`);
 	}
 	if (b.file !== undefined && typeof b.file !== "string") {
-		throw new Error(`${context}: codeBlock.file must be a string`);
+		throw new Error(`${context}: content.file must be a string`);
 	}
 	if (b.lines !== undefined && typeof b.lines !== "string") {
-		throw new Error(`${context}: codeBlock.lines must be a string`);
+		throw new Error(`${context}: content.lines must be a string`);
 	}
 	if (b.title !== undefined && typeof b.title !== "string") {
-		throw new Error(`${context}: codeBlock.title must be a string`);
+		throw new Error(`${context}: content.title must be a string`);
+	}
+	if (b.showSource !== undefined && typeof b.showSource !== "boolean") {
+		throw new Error(`${context}: content.showSource must be a boolean`);
 	}
 	if (b.highlights !== undefined) {
 		if (!Array.isArray(b.highlights) || b.highlights.some((h) => typeof h !== "number")) {
-			throw new Error(`${context}: codeBlock.highlights must be an array of numbers`);
+			throw new Error(`${context}: content.highlights must be an array of numbers`);
+		}
+	}
+
+	if (isMarkdownLang(b.lang)) {
+		if (b.lines !== undefined) {
+			throw new Error(`${context}: content.lines is not allowed for markdown content`);
+		}
+		if (b.highlights !== undefined) {
+			throw new Error(`${context}: content.highlights is not allowed for markdown content`);
 		}
+		return {
+			source: b.source,
+			lang: b.lang.trim().toLowerCase() as "md" | "markdown",
+			file: b.file,
+			title: b.title,
+			showSource: b.showSource,
+		};
 	}
-	return b as unknown as CodeBlock;
+
+	if (b.showSource !== undefined) {
+		throw new Error(`${context}: content.showSource is only valid when content.lang is "md" or "markdown"`);
+	}
+
+	return {
+		source: b.source,
+		lang: b.lang,
+		file: b.file,
+		title: b.title,
+		lines: b.lines,
+		highlights: b.highlights as number[] | undefined,
+	};
 }
 
 function validateOption(option: unknown, questionId: string, index: number): OptionValue {
@@ -169,9 +219,17 @@ function validateOption(option: unknown, questionId: string, index: number): Opt
 			);
 		}
 		if (o.code !== undefined) {
-			validateCodeBlock(o.code, `Question "${questionId}" option "${o.label}"`);
+			throw new Error(
+				`Question "${questionId}" option "${o.label}": legacy "code" is no longer supported; use "content"`
+			);
 		}
-		return option as RichOption;
+		if (o.content !== undefined) {
+			return {
+				label: o.label,
+				content: validateContentBlock(o.content, `Question "${questionId}" option "${o.label}"`),
+			};
+		}
+		return { label: o.label };
 	}
 	throw new Error(
 		`Question "${questionId}": option at index ${index} must be a string or object with label`
@@ -240,7 +298,7 @@ function validateBasicStructure(data: unknown): QuestionsFile {
 				throw new Error(`Question "${q.id}": options must be a non-empty array`);
 			}
 			for (let j = 0; j < q.options.length; j++) {
-				validateOption(q.options[j], q.id as string, j);
+				q.options[j] = validateOption(q.options[j], q.id as string, j);
 			}
 		}
 
@@ -249,7 +307,10 @@ function validateBasicStructure(data: unknown): QuestionsFile {
 		}
 
 		if (q.codeBlock !== undefined) {
-			validateCodeBlock(q.codeBlock, `Question "${q.id}"`);
+			throw new Error(`Question "${q.id}": legacy "codeBlock" is no longer supported; use "content"`);
+		}
+		if (q.content !== undefined) {
+			q.content = validateContentBlock(q.content, `Question "${q.id}"`);
 		}
 
 		if (q.conviction !== undefined) {

package/server.ts

@@ -207,7 +207,7 @@ export interface InterviewServerCallbacks {
 		existingOptions: string[],
 		signal: AbortSignal,
 		mode: "add" | "review",
-	) => Promise<{ options: string[] }>;
+	) => Promise<{ options: string[]; question?: string }>;
 }
 
 export interface InterviewServerHandle {
@@ -387,6 +387,35 @@ function ensureQuestionId(
 	return { ok: true, question };
 }
 
+function syncRecommendations(question: Question, options: string[]): void {
+	if (!question.recommended) return;
+
+	if (question.type === "single") {
+		if (typeof question.recommended === "string" && options.includes(question.recommended)) {
+			return;
+		}
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+
+	if (question.type !== "multi") {
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+
+	const nextRecommended = (Array.isArray(question.recommended)
+		? question.recommended
+		: [question.recommended]).filter((option) => options.includes(option));
+	if (nextRecommended.length === 0) {
+		delete question.recommended;
+		delete question.conviction;
+		return;
+	}
+	question.recommended = nextRecommended;
+}
+
 // HTML generation for saved interviews
 interface SavedFromMeta {
 	cwd: string;
@@ -408,6 +437,155 @@ function escapeHtml(str: string): string {
 		.replace(/"/g, "&quot;");
 }
 
+function isMarkdownLang(lang: string | undefined): boolean {
+	if (!lang) return false;
+	const normalized = lang.trim().toLowerCase();
+	return normalized === "md" || normalized === "markdown";
+}
+
+function renderLightMarkdownHtml(text: string): string {
+	let html = escapeHtml(text);
+	html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+	html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+	html = html.replace(/\n/g, "<br>");
+	html = html.replace(/\s(\d+\.)\s/g, "<br>$1 ");
+	return html;
+}
+
+function renderMarkdownPreviewHtml(markdown: string): string {
+	const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+	const html: string[] = [];
+	const paragraph: string[] = [];
+	let listType: "ul" | "ol" | null = null;
+	let inFence = false;
+	let fenceLang = "";
+	let fenceLines: string[] = [];
+
+	const flushParagraph = () => {
+		if (paragraph.length === 0) return;
+		html.push(`<p>${renderLightMarkdownHtml(paragraph.join(" "))}</p>`);
+		paragraph.length = 0;
+	};
+
+	const closeList = () => {
+		if (!listType) return;
+		html.push(listType === "ol" ? "</ol>" : "</ul>");
+		listType = null;
+	};
+
+	for (const rawLine of lines) {
+		const line = rawLine ?? "";
+
+		if (inFence) {
+			if (/^```/.test(line.trim())) {
+				html.push(`<pre class="markdown-fence"><code${fenceLang ? ` data-lang="${escapeHtml(fenceLang)}"` : ""}>${escapeHtml(fenceLines.join("\n"))}</code></pre>`);
+				inFence = false;
+				fenceLang = "";
+				fenceLines = [];
+			} else {
+				fenceLines.push(line);
+			}
+			continue;
+		}
+
+		const fenceStart = line.match(/^```\s*([^\s`]*)\s*$/);
+		if (fenceStart) {
+			flushParagraph();
+			closeList();
+			inFence = true;
+			fenceLang = fenceStart[1] || "";
+			fenceLines = [];
+			continue;
+		}
+
+		if (!line.trim()) {
+			flushParagraph();
+			closeList();
+			continue;
+		}
+
+		const headingMatch = line.match(/^\s{0,3}(#{1,6})\s+(.+)$/);
+		if (headingMatch) {
+			flushParagraph();
+			closeList();
+			const level = headingMatch[1].length;
+			html.push(`<h${level}>${renderLightMarkdownHtml(headingMatch[2].trim())}</h${level}>`);
+			continue;
+		}
+
+		const quoteMatch = line.match(/^>\s?(.*)$/);
+		if (quoteMatch) {
+			flushParagraph();
+			closeList();
+			html.push(`<blockquote><p>${renderLightMarkdownHtml(quoteMatch[1])}</p></blockquote>`);
+			continue;
+		}
+
+		const orderedMatch = line.match(/^\s*\d+\.\s+(.+)$/);
+		if (orderedMatch) {
+			flushParagraph();
+			if (listType !== "ol") {
+				closeList();
+				html.push("<ol>");
+				listType = "ol";
+			}
+			html.push(`<li>${renderLightMarkdownHtml(orderedMatch[1])}</li>`);
+			continue;
+		}
+
+		const unorderedMatch = line.match(/^\s*[-*]\s+(.+)$/);
+		if (unorderedMatch) {
+			flushParagraph();
+			if (listType !== "ul") {
+				closeList();
+				html.push("<ul>");
+				listType = "ul";
+			}
+			html.push(`<li>${renderLightMarkdownHtml(unorderedMatch[1])}</li>`);
+			continue;
+		}
+
+		closeList();
+		paragraph.push(line.trim());
+	}
+
+	if (inFence) {
+		html.push(`<pre class="markdown-fence"><code${fenceLang ? ` data-lang="${escapeHtml(fenceLang)}"` : ""}>${escapeHtml(fenceLines.join("\n"))}</code></pre>`);
+	}
+
+	flushParagraph();
+	closeList();
+	return html.join("\n");
+}
+
+function renderContentBlockHtml(content: Question["content"] | undefined): string {
+	if (!content?.source) return "";
+
+	const markdownPreview = isMarkdownLang(content.lang) && content.showSource !== true;
+	const headerParts: string[] = [];
+	if (content.title) {
+		headerParts.push(`<span class="code-block-title">${escapeHtml(content.title)}</span>`);
+	}
+	if (content.file) {
+		headerParts.push(`<span class="code-block-file">${escapeHtml(content.file)}</span>`);
+	}
+	if (content.lines) {
+		headerParts.push(`<span class="code-block-lines">L${escapeHtml(content.lines)}</span>`);
+	}
+	if (content.lang && content.lang !== "diff") {
+		headerParts.push(`<span class="code-block-lang">${escapeHtml(content.lang)}</span>`);
+	}
+	const headerHtml = headerParts.length > 0
+		? `<div class="code-block-header">${headerParts.join("")}</div>`
+		: "";
+
+	if (markdownPreview) {
+		return `<div class="code-block markdown-content-block">${headerHtml}<div class="markdown-preview">${renderMarkdownPreviewHtml(content.source)}</div></div>`;
+	}
+
+	return `<div class="code-block">${headerHtml}<pre class="saved-code"><code>${escapeHtml(content.source)}</code></pre></div>`;
+}
+
 function renderMediaCaptionHtml(media: MediaBlock): string {
 	if (!media.caption) return "";
 	return `<div class="media-caption">${escapeHtml(media.caption)}</div>`;
@@ -516,14 +694,12 @@ function renderQuestionsHtml(questionsList: Question[], answers: ResponseItem[])
 			const mediaHtml = renderMediaListHtml(q.media);
 
 			if (q.type === "info") {
-				const codeHtml = q.codeBlock
-					? `<pre class="saved-code"><code>${escapeHtml(q.codeBlock.code)}</code></pre>`
-					: "";
+				const contentHtml = renderContentBlockHtml(q.content);
 				return `
       <div class="${weightClasses(q)}">
         <h2>${escapeHtml(q.question)}</h2>
         ${q.context ? `<p class="question-context">${escapeHtml(q.context)}</p>` : ""}
-        ${codeHtml}
+        ${contentHtml}
         ${mediaHtml}
       </div>
     `;
@@ -550,9 +726,7 @@ function renderQuestionsHtml(questionsList: Question[], answers: ResponseItem[])
 				answerHtml = `<div class="saved-answer">${savedAnswerItemHtml(String(value), q)}</div>`;
 			}
 
-			const codeHtml = q.codeBlock
-				? `<pre class="saved-code"><code>${escapeHtml(q.codeBlock.code)}</code></pre>`
-				: "";
+			const contentHtml = renderContentBlockHtml(q.content);
 
 			const attachHtml =
 				attachments.length > 0
@@ -569,7 +743,7 @@ function renderQuestionsHtml(questionsList: Question[], answers: ResponseItem[])
       <div class="${weightClasses(q)}">
         <h2>${numPrefix}${escapeHtml(q.question)}</h2>
         ${contextHtml}
-        ${codeHtml}
+        ${contentHtml}
         ${mediaHtml}
         ${answerHtml}
         ${attachHtml}
@@ -631,8 +805,11 @@ const SAVED_VIEW_STYLES = `
   padding: 12px;
   background: var(--bg-body);
   border-radius: var(--radius);
-  overflow-x: auto;
+  overflow-x: hidden;
   font-size: 13px;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  word-break: break-word;
 }
 .saved-answer {
   color: var(--fg);
@@ -1258,9 +1435,7 @@ export async function startInterviewServer(
 				}
 
 				// Copy local media images to snapshot and rewrite paths
-				const rewrittenQuestions = await copyMediaImages(
-					questions.questions, imagesPath, cwd
-				);
+				const rewrittenQuestions = await copyMediaImages(questions.questions, imagesPath, cwd);
 				const snapshotQuestions: QuestionsFile = {
 					...questions,
 					questions: rewrittenQuestions,
@@ -1321,6 +1496,10 @@ export async function startInterviewServer(
 					sendJson(res, 400, { ok: false, error: "Invalid question for generation" });
 					return;
 				}
+				if (question.options.some((option) => typeof option !== "string")) {
+					sendJson(res, 400, { ok: false, error: "Generation is not available for rich options" });
+					return;
+				}
 
 				const existingOptions = Array.isArray(payload.existingOptions)
 					? payload.existingOptions.filter((o): o is string => typeof o === "string")
@@ -1341,7 +1520,35 @@ export async function startInterviewServer(
 						controller.signal,
 						mode,
 					);
-					sendJson(res, 200, { ok: true, options: result.options });
+
+					const uniqueOptions: string[] = [];
+					const seenOptions = new Set<string>();
+					for (const option of result.options) {
+						const trimmed = option.trim();
+						if (!trimmed) continue;
+						const key = trimmed.toLowerCase();
+						if (seenOptions.has(key)) continue;
+						seenOptions.add(key);
+						uniqueOptions.push(trimmed);
+					}
+
+					const reviewedQuestion = typeof result.question === "string" ? result.question.trim() : undefined;
+					const storedQuestion = questions.questions.find((q) => q.id === payload.questionId);
+					if (storedQuestion) {
+						if (mode === "review" && reviewedQuestion && uniqueOptions.length > 0) {
+							storedQuestion.question = reviewedQuestion;
+							storedQuestion.options = uniqueOptions;
+							syncRecommendations(storedQuestion, uniqueOptions);
+						} else if (mode === "add") {
+							const existingKeys = new Set(existingOptions.map((option) => option.trim().toLowerCase()));
+							const newOptions = uniqueOptions.filter((option) => !existingKeys.has(option.toLowerCase()));
+							if (newOptions.length > 0) {
+								storedQuestion.options = storedQuestion.options.concat(newOptions);
+							}
+						}
+					}
+
+					sendJson(res, 200, { ok: true, options: uniqueOptions, question: reviewedQuestion });
 				} catch (err) {
 					if (controller.signal.aborted) {
 						sendJson(res, 409, { ok: false, error: "Request cancelled" });