pi-soly 1.11.2 → 1.12.0

package/artifact/session.ts

@@ -0,0 +1,368 @@
+// =============================================================================
+// session.ts — shared handle + paths for the artifact server (per project)
+// =============================================================================
+//
+// The artifact tool, the `/artifacts` command, and the status chrome all need
+// the current server (gallery URL, count, list) — and they need it to survive
+// /reload, pi restarts, AND having a second pi window open in the same folder.
+//
+// So the server is PER PROJECT, not per session:
+//   • files live in a STABLE per-project dir (hash of the cwd, under the OS temp
+//     dir or a configured base) with an on-disk manifest (index.json) — restored
+//     on every start;
+//   • the server binds a PINNED 127.0.0.1 port + route token derived from the
+//     cwd → the SAME gallery URL across windows and restarts;
+//   • a registry file (server.json) lets a second window DISCOVER an
+//     already-running server and reuse it as a remote client (mutating it over
+//     HTTP) instead of starting a second one.
+//
+// This module owns the discovery (registry + liveness probe), the in-process
+// handle (local server OR remote client), and the path math so every surface
+// resolves the same directory and the same URL.
+// =============================================================================
+
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as http from "node:http";
+import { createHash } from "node:crypto";
+import { ArtifactServer, type ArtifactHandle, type ArtifactEntry } from "./server.ts";
+import type { GalleryEntry } from "./render.ts";
+import { atomicWriteFileSync } from "../util.ts";
+
+/** Pinned ports live just below the OS ephemeral range, in a narrow band so a
+ *  project's URL stays stable while keeping collision odds low. */
+const PINNED_PORT_BASE = 43120;
+const PINNED_PORT_RANGE = 2048;
+
+/** Liveness probe / write timeouts (ms) — short, since everything is 127.0.0.1. */
+const PROBE_TIMEOUT_MS = 300;
+const WRITE_TIMEOUT_MS = 2000;
+
+let current: ArtifactHandle | null = null;
+let currentDir: string | null = null;
+/** True when THIS process started (owns) the running server. */
+let isOwner = false;
+
+/** The active artifact handle, or null if none has started this run. */
+export function getArtifactServer(): ArtifactHandle | null {
+	return current;
+}
+
+/** Base artifact directory: config override (abs / ~ / relative to cwd) or the
+ *  OS temp dir under pi-soly-artifacts/. */
+export function resolveArtifactBase(configDir: string, cwd: string): string {
+	const d = configDir.trim();
+	if (!d) return path.join(os.tmpdir(), "pi-soly-artifacts");
+	if (d === "~" || d.startsWith("~/") || d.startsWith("~\\")) {
+		return path.join(os.homedir(), d.slice(1).replace(/^[/\\]/, ""));
+	}
+	return path.isAbsolute(d) ? d : path.join(cwd, d);
+}
+
+/** Stable per-project key (hash of the absolute cwd) → same folder across
+ *  reloads/restarts, so a project's artifacts persist and stay browsable. */
+export function projectKey(cwd: string): string {
+	return projectHash(cwd).slice(0, 12);
+}
+
+/** Full hex hash of the absolute cwd — the single source for port + token. */
+function projectHash(cwd: string): string {
+	return createHash("sha1").update(path.resolve(cwd)).digest("hex");
+}
+
+/** 16-hex pinned route token derived from cwd (stable across windows/restarts). */
+export function pinnedToken(cwd: string): string {
+	return projectHash(cwd).slice(0, 16);
+}
+
+/** Pinned 127.0.0.1 port for this project (falls back to ephemeral if busy). */
+export function pinnedPort(cwd: string): number {
+	const buf = createHash("sha1").update(path.resolve(cwd)).digest();
+	return PINNED_PORT_BASE + (buf.readUInt32BE(0) % PINNED_PORT_RANGE);
+}
+
+/** The stable per-project artifact directory. */
+export function artifactDir(configDir: string, cwd: string): string {
+	return path.join(resolveArtifactBase(configDir, cwd), projectKey(cwd));
+}
+
+// ----------------------------------------------------------------------------
+// Registry: lets one pi window discover a server another window already runs
+// ----------------------------------------------------------------------------
+
+type Registry = { port: number; token: string; pid: number; startedAt: number };
+
+function registryPath(dir: string): string {
+	return path.join(dir, "server.json");
+}
+
+function readRegistry(dir: string): Registry | null {
+	try {
+		const raw = JSON.parse(fs.readFileSync(registryPath(dir), "utf-8")) as Partial<Registry>;
+		if (raw && typeof raw.port === "number" && typeof raw.token === "string") {
+			return { port: raw.port, token: raw.token, pid: raw.pid ?? 0, startedAt: raw.startedAt ?? 0 };
+		}
+	} catch {
+		// missing or corrupt — treat as "no known server"
+	}
+	return null;
+}
+
+function writeRegistry(dir: string, reg: Registry): void {
+	try {
+		atomicWriteFileSync(registryPath(dir), JSON.stringify(reg));
+	} catch {
+		// best effort
+	}
+}
+
+function deleteRegistry(dir: string): void {
+	try {
+		fs.unlinkSync(registryPath(dir));
+	} catch {
+		// best effort
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Tiny 127.0.0.1 HTTP helpers used by the probe + the remote client
+// ----------------------------------------------------------------------------
+
+function httpGetJson(port: number, token: string, seg: string, timeoutMs: number): Promise<unknown> {
+	return new Promise((resolve) => {
+		const req = http.get(
+			{ hostname: "127.0.0.1", port, path: `/${token}/${seg}`, timeout: timeoutMs },
+			(res) => {
+				let data = "";
+				res.on("data", (c: Buffer | string) => (data += c));
+				res.on("end", () => {
+					if (res.statusCode && res.statusCode < 300) {
+						try {
+							resolve(data ? JSON.parse(data) : null);
+						} catch {
+							resolve(null);
+						}
+					} else {
+						resolve(null);
+					}
+				});
+			},
+		);
+		req.on("timeout", () => req.destroy());
+		req.on("error", () => resolve(null));
+	});
+}
+
+function httpPostJson(
+	port: number,
+	token: string,
+	seg: string,
+	body: unknown,
+	timeoutMs: number,
+): Promise<unknown> {
+	return new Promise((resolve, reject) => {
+		const data = JSON.stringify(body);
+		const req = http.request(
+			{
+				hostname: "127.0.0.1",
+				port,
+				path: `/${token}/${seg}`,
+				method: "POST",
+				headers: { "content-type": "application/json", "content-length": Buffer.byteLength(data) },
+				timeout: timeoutMs,
+			},
+			(res) => {
+				let d = "";
+				res.on("data", (c: Buffer | string) => (d += c));
+				res.on("end", () => {
+					if (res.statusCode && res.statusCode < 300) {
+						try {
+							resolve(d ? JSON.parse(d) : null);
+						} catch {
+							resolve(null);
+						}
+					} else {
+						reject(new Error(`artifact server responded ${res.statusCode}`));
+					}
+				});
+			},
+		);
+		req.on("timeout", () => req.destroy(new Error("artifact server write timed out")));
+		req.on("error", reject);
+		req.end(data);
+	});
+}
+
+/** Probe a server's list endpoint; returns entries if alive, else null. */
+async function probeEntries(port: number, token: string): Promise<GalleryEntry[] | null> {
+	const r = (await httpGetJson(port, token, "list", PROBE_TIMEOUT_MS)) as GalleryEntry[] | null;
+	return Array.isArray(r) ? r : null;
+}
+
+// ----------------------------------------------------------------------------
+// Remote client: reuse another window's already-running server over HTTP
+// ----------------------------------------------------------------------------
+
+/**
+ * A {@link ArtifactHandle} backed by ANOTHER pi window's running server. Mutates
+ * the owner's list over HTTP; keeps a local cache so sync surfaces (the footer
+ * count, `/artifacts` list) keep working without a round-trip on every render.
+ */
+export class RemoteArtifactClient implements ArtifactHandle {
+	private opened = false;
+	private cached: GalleryEntry[] = [];
+
+	constructor(
+		private readonly port: number,
+		private readonly token: string,
+		initial: GalleryEntry[],
+	) {
+		this.cached = initial.slice();
+	}
+
+	get count(): number {
+		return this.cached.length;
+	}
+
+	galleryUrl(): string {
+		return `http://127.0.0.1:${this.port}/${this.token}/`;
+	}
+
+	private artifactUrl(file: string): string {
+		return `http://127.0.0.1:${this.port}/${this.token}/a/${encodeURIComponent(path.basename(file))}`;
+	}
+
+	list(): ArtifactEntry[] {
+		return this.cached.map((e) => ({ ...e, url: this.artifactUrl(e.file) }));
+	}
+
+	/** Re-probe the owner server; refresh the cache if still alive. */
+	async refresh(): Promise<boolean> {
+		const entries = await probeEntries(this.port, this.token);
+		if (!entries) return false;
+		this.cached = entries;
+		return true;
+	}
+
+	async register(title: string, file: string, id?: string): Promise<string> {
+		const res = (await httpPostJson(
+			this.port,
+			this.token,
+			"register",
+			{ title, file: path.basename(file), id },
+			WRITE_TIMEOUT_MS,
+		)) as { entries?: GalleryEntry[] } | null;
+		if (res?.entries) this.cached = res.entries;
+		return this.artifactUrl(file);
+	}
+
+	remove(id: string): boolean {
+		const i = this.cached.findIndex((e) => e.id === id);
+		if (i < 0) return false;
+		this.cached.splice(i, 1);
+		void httpPostJson(this.port, this.token, "remove", { id }, WRITE_TIMEOUT_MS).catch(() => {});
+		return true;
+	}
+
+	clear(): number {
+		const n = this.cached.length;
+		this.cached = [];
+		void httpPostJson(this.port, this.token, "clear", {}, WRITE_TIMEOUT_MS).catch(() => {});
+		return n;
+	}
+
+	consumeFirstOpen(): boolean {
+		if (this.opened) return false;
+		this.opened = true;
+		return true;
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Discovery + lifecycle
+// ----------------------------------------------------------------------------
+
+/**
+ * Get-or-resolve the artifact handle for `dir`/`cwd`:
+ *   1. if already resolved this run, return it;
+ *   2. if another window's server is alive (registry or pinned port), reuse it
+ *      as a {@link RemoteArtifactClient};
+ *   3. otherwise start our own {@link ArtifactServer} on the pinned port and
+ *      become its owner (writing the registry so later windows find us).
+ */
+export async function ensureArtifactServer(dir: string, cwd: string): Promise<ArtifactHandle> {
+	fs.mkdirSync(dir, { recursive: true });
+	if (current) {
+		if (current instanceof RemoteArtifactClient) {
+			// Another window's server may have died since we resolved — re-probe
+			// before trusting the cache; if it's gone, start our own below.
+			if (await current.refresh()) return current;
+			current = null;
+			currentDir = null;
+			isOwner = false;
+		} else {
+			return current; // we own it → valid for this whole run
+		}
+	}
+
+	const token = pinnedToken(cwd);
+	const port = pinnedPort(cwd);
+
+	// Reuse path A: a registry written by another window points at a live server.
+	const reg = readRegistry(dir);
+	if (reg && reg.token === token) {
+		const entries = await probeEntries(reg.port, token);
+		if (entries) {
+			current = new RemoteArtifactClient(reg.port, token, entries);
+			currentDir = dir;
+			isOwner = false;
+			return current;
+		}
+	}
+
+	// Reuse path B: no (matching) registry, but a server with our token may still
+	// be up on the pinned port — probe it directly before starting our own.
+	if (!reg || reg.port !== port || reg.token !== token) {
+		const entries = await probeEntries(port, token);
+		if (entries) {
+			writeRegistry(dir, { port, token, pid: process.pid, startedAt: Date.now() });
+			current = new RemoteArtifactClient(port, token, entries);
+			currentDir = dir;
+			isOwner = false;
+			return current;
+		}
+	}
+
+	// Start path: no live server — own one on the pinned port.
+	const server = new ArtifactServer(dir, port, token);
+	await server.ensureStarted();
+	writeRegistry(dir, { port: server.boundPort, token, pid: process.pid, startedAt: Date.now() });
+	current = server;
+	currentDir = dir;
+	isOwner = true;
+	return current;
+}
+
+/** Drop the cached handle so the next {@link ensureArtifactServer} re-probes.
+ *  Used when a register call fails (the owner likely died) before a retry. */
+export function invalidateArtifactServer(): void {
+	current = null;
+	currentDir = null;
+	isOwner = false;
+}
+
+/**
+ * Stop the server if THIS process owns it (frees the pinned port + removes the
+ * registry so a later window starts fresh). If we were only a client, leave the
+ * owner's server and registry untouched. Safe to call when nothing is running.
+ */
+export function disposeArtifactServer(): void {
+	if (isOwner && current instanceof ArtifactServer) {
+		current.stop();
+		if (currentDir) deleteRegistry(currentDir);
+	}
+	current = null;
+	currentDir = null;
+	isOwner = false;
+}

package/ask/README.md

@@ -12,8 +12,15 @@ showing a **tabbed, multi-question picker** in pi's TUI.
   is marked ⭐
 - **Single-select** (default) — Enter on an option auto-advances to the next
   question; on the last question, Enter submits
-- **Multi-select** — Enter toggles checkboxes; the last question shows a
-  visible "Submit" row
+- **Multi-select** — Space toggles checkboxes; `minSelect`/`maxSelect` bound how
+  many may be chosen; the last question shows a visible "Submit" row
+- **Free-text questions** — `freeText: true` (with empty `options`) makes a
+  typed-answer question; it's optional (blank is allowed)
+- **Option previews** — per-option `preview` shows a side panel while focused;
+  fenced ```code blocks in it are syntax-highlighted
+- **"Other…"** — per-question `allowOther: true` adds a free-text custom choice
+- **Notes & skip** — `n` attaches a free-text note to any answer; `s` skips a
+  question (returned in `skipped`)
 - **Cancelled detection** — `Esc` resolves `{cancelled: true}`
 
 ## Usage from an LLM
@@ -83,8 +90,10 @@ Result:
 | `1` – `4` | Instant-pick that option |
 | `Tab` / `→` | Next question |
 | `Shift+Tab` / `←` / `Backspace` | Previous question |
-| `Space` | Multi-select only: toggle the current option. On "Other…", opens the input dialog. |
-| `Enter` | **Single-select:** confirm + advance (or submit on last). **Multi-select:** advance to next question (or submit on last + all answered). Does NOT toggle. |
+| `Space` | Multi-select only: toggle the current option (ignored past `maxSelect`). On "Other…", opens the input dialog. |
+| `Enter` | **Single-select:** confirm + advance (or submit on last). **Multi-select:** advance to next question (or submit on last + all answered). Does NOT toggle. **Free-text:** commit the typed answer + advance/submit. |
+| `n` | Add/edit a free-text note on the current answer |
+| `s` | Skip the current question (reported as skipped, omitted from answers) |
 | `Esc` | Cancel (returns `{cancelled: true}`) |
 
 Multi-select: **Space toggles, Enter advances/submits**. Single-select
@@ -95,17 +104,20 @@ shows `⏎ submit` in accent color.
 ## Limits
 
 - 2–4 options per question (more is bad UX; the picker is meant for focused
-  choices, not long lists)
+  choices, not long lists) — except `freeText: true` questions, which take no
+  options
 - 1–6 questions per call (more = tab-switching fatigue)
 - At most 1 `recommended: true` per question
+- `minSelect`/`maxSelect` apply to multi-select only and must fall within the
+  option count
 - TUI and RPC modes only (`hasUI: true`); print mode returns an error
 
 ## Development
 
 ```bash
-cd packages/pi-soly/ask
-bun test              # runs tests/picker.test.ts
-bun run typecheck     # tsc --noEmit
+cd packages/pi-soly
+bun test tests/ask-picker.test.ts   # picker behavior (C/D/E/A features)
+bun run typecheck                   # tsc --noEmit
 ```
 
 ## Why a separate module?

package/ask/index.ts

@@ -21,63 +21,99 @@
 // =============================================================================
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { highlightCode } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { AskProComponent, type AskProResult } from "./picker.ts";
-import { buildAskProSection } from "./prompt.ts";
 
-export default function piAskExtension(pi: ExtensionAPI) {
-	// Inject a "when to use ask_pro" section into the system prompt so the
-	// LLM reaches for the picker at the right times (and avoids overusing
-	// it for trivial yes/no or open-ended questions).
-	pi.on("before_agent_start", async (event) => {
-		return {
-			systemPrompt: event.systemPrompt + buildAskProSection(),
-		};
+type ToolError = {
+	content: { type: "text"; text: string }[];
+	details: Record<string, unknown>;
+};
+
+type BoundsCheck = {
+	header: string;
+	multiSelect?: boolean;
+	minSelect?: number;
+	maxSelect?: number;
+	allowOther?: boolean;
+	options: unknown[];
+};
+
+/** Validate multi-select min/max bounds. Returns a tool error, or null if OK.
+ *  No-op for single-select questions. */
+function validateSelectBounds(q: BoundsCheck, i: number): ToolError | null {
+	if (!q.multiSelect) return null;
+	const max = q.options.length + (q.allowOther ? 1 : 0);
+	const err = (text: string, error: string): ToolError => ({
+		content: [{ type: "text", text: `ask_pro: Q${i + 1} ("${q.header}") ${text}` }],
+		details: { error, questionIdx: i },
 	});
+	if (q.minSelect !== undefined && (q.minSelect < 1 || q.minSelect > max)) {
+		return err(`minSelect ${q.minSelect} out of range (1-${max}).`, "bad_min_select");
+	}
+	if (q.maxSelect !== undefined && (q.maxSelect < 1 || q.maxSelect > max)) {
+		return err(`maxSelect ${q.maxSelect} out of range (1-${max}).`, "bad_max_select");
+	}
+	if (
+		q.minSelect !== undefined &&
+		q.maxSelect !== undefined &&
+		q.minSelect > q.maxSelect
+	) {
+		return err(`minSelect ${q.minSelect} > maxSelect ${q.maxSelect}.`, "min_gt_max");
+	}
+	return null;
+}
 
+export default function piAskExtension(pi: ExtensionAPI) {
+	// Usage guidance lives in the soly-framework skill (loaded on demand) +
+	// a one-line pointer in the main soly system prompt — not injected here.
 	pi.registerTool({
 		name: "ask_pro",
-		label: "pi-ask ask_pro",
+		label: "soly · ask_pro",
 		description:
-			"Ask the user multiple questions at once via a tabbed picker. Each question is a tab at the top. Options are numbered (1-N instant-pick), the recommended answer is marked ⭐. Supports single-select (default, auto-advance on pick) and multi-select (Enter toggles, last question shows Submit). All answers returned in one call. Use for progressive Q&A flows like `soly discuss`.",
+			"Ask the user several questions at once via a tabbed picker; returns all answers in one call. Per question: single-select (default), `multiSelect` (+ `minSelect`/`maxSelect`), `allowOther` (free-text choice), or `freeText` (typed answer, no options). Per option: `recommended` (⭐) and `preview` (side panel, fenced code highlighted). User can skip (`s`) or note (`n`). Prefer over one-by-one questions; good for `soly discuss`.",
 		parameters: Type.Object({
 			questions: Type.Array(
 				Type.Object({
-					header: Type.String({
-						description: "Short label for the tab (1-2 words, max 12 chars).",
-					}),
-					question: Type.String({
-						description: "The full question to ask.",
-					}),
+					header: Type.String({ description: "Tab label (1-2 words)." }),
+					question: Type.String({ description: "The question." }),
 					options: Type.Array(
 						Type.Object({
-							label: Type.String({
-								description: "Short label (1-5 words).",
-							}),
+							label: Type.String({ description: "Short label." }),
 							description: Type.Optional(
-								Type.String({
-									description: "1-2 sentence explanation. Shown below the label.",
-								}),
+								Type.String({ description: "1-2 sentence explanation, shown below the label." }),
 							),
 							recommended: Type.Optional(
-								Type.Boolean({
-									description: "Mark as ⭐ recommended answer.",
+								Type.Boolean({ description: "Mark ⭐ recommended (at most one)." }),
+							),
+							preview: Type.Optional(
+								Type.String({
+									description:
+										"Snippet shown in a side panel when focused (code shape, signature, sample). Fenced ```code is highlighted.",
 								}),
 							),
 						}),
-						{ description: "2-4 concrete options." },
+						{ description: "2-4 options. Empty ([]) when freeText is true." },
 					),
 					multiSelect: Type.Optional(
+						Type.Boolean({ description: "Allow multiple picks (default single-select)." }),
+					),
+					allowOther: Type.Optional(
+						Type.Boolean({ description: "Add a free-text 'Other…' choice." }),
+					),
+					minSelect: Type.Optional(
+						Type.Number({ description: "Multi-select: min picks (default 1)." }),
+					),
+					maxSelect: Type.Optional(
+						Type.Number({ description: "Multi-select: max picks (default: no limit)." }),
+					),
+					freeText: Type.Optional(
 						Type.Boolean({
-							description:
-								"If true, user can pick multiple (checkboxes, Enter toggles). If false (default), single-select with auto-advance.",
+							description: "No options — user types an answer (optional, blank allowed).",
 						}),
 					),
 				}),
-				{
-					description:
-						"Questions to ask, in tab order. Max ~5 recommended (more hurts UX).",
-				},
+				{ description: "Questions in tab order (≤5 recommended)." },
 			),
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
@@ -117,12 +153,27 @@ export default function piAskExtension(pi: ExtensionAPI) {
 			for (let i = 0; i < params.questions.length; i++) {
 				const q = params.questions[i];
 				if (!q) continue;
+				// Free-text questions carry no options — skip the option checks.
+				if (q.freeText) {
+					if (q.multiSelect) {
+						return {
+							content: [
+								{
+									type: "text",
+									text: `ask_pro: Q${i + 1} ("${q.header}") can't be both freeText and multiSelect.`,
+								},
+							],
+							details: { error: "freetext_multiselect", questionIdx: i },
+						};
+					}
+					continue;
+				}
 				if (q.options.length < 2 || q.options.length > 4) {
 					return {
 						content: [
 							{
 								type: "text",
-								text: `ask_pro: Q${i + 1} ("${q.header}") has ${q.options.length} options, need 2-4.`,
+								text: `ask_pro: Q${i + 1} ("${q.header}") has ${q.options.length} options, need 2-4 (or set freeText:true).`,
 							},
 						],
 						details: {
@@ -145,6 +196,9 @@ export default function piAskExtension(pi: ExtensionAPI) {
 						details: { error: "multiple_recommended", questionIdx: i },
 					};
 				}
+				// Validate multi-select min/max bounds when provided.
+				const bounds = validateSelectBounds(q, i);
+				if (bounds) return bounds;
 			}
 
 			// --- show the picker ---
@@ -159,7 +213,8 @@ export default function piAskExtension(pi: ExtensionAPI) {
 						theme: askTheme,
 						keybindings,
 						done,
-						title: `pi-ask — ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
+						title: `soly · ${params.questions.length} question${params.questions.length > 1 ? "s" : ""}`,
+						highlight: highlightCode,
 					});
 				},
 			);
@@ -179,6 +234,7 @@ export default function piAskExtension(pi: ExtensionAPI) {
 
 			const answers = result.answers ?? {};
 			const notes = result.notes ?? {};
+			const skipped = new Set(result.skipped ?? []);
 			// Pretty-print for the LLM
 			const out: string[] = ["User answers:"];
 			for (let i = 0; i < params.questions.length; i++) {
@@ -186,7 +242,9 @@ export default function piAskExtension(pi: ExtensionAPI) {
 				if (!q) continue;
 				const a = answers[i];
 				let line: string;
-				if (a === undefined) {
+				if (skipped.has(i)) {
+					line = `  Q${i + 1} (${q.header}): (skipped)`;
+				} else if (a === undefined) {
 					line = `  Q${i + 1} (${q.header}): (no answer)`;
 				} else if (Array.isArray(a)) {
 					const parts: string[] = [];
@@ -200,6 +258,8 @@ export default function piAskExtension(pi: ExtensionAPI) {
 					line = `  Q${i + 1} (${q.header}) [multi]: ${parts.join(", ")}`;
 				} else if (typeof a === "number") {
 					line = `  Q${i + 1} (${q.header}): ${q.options[a]?.label ?? `?${a}`}`;
+				} else if (q.freeText) {
+					line = `  Q${i + 1} (${q.header}): "${a}"`;
 				} else {
 					line = `  Q${i + 1} (${q.header}) [Other]: "${a}"`;
 				}
@@ -212,7 +272,11 @@ export default function piAskExtension(pi: ExtensionAPI) {
 
 			return {
 				content: [{ type: "text", text: out.join("\n") }],
-				details: { answers, notes: Object.keys(notes).length > 0 ? notes : undefined },
+				details: {
+					answers,
+					notes: Object.keys(notes).length > 0 ? notes : undefined,
+					skipped: skipped.size > 0 ? [...skipped] : undefined,
+				},
 			};
 		},
 	});