@danypops/papyrus 0.19.0 → 0.20.0

package/README.md

@@ -162,9 +162,15 @@ Rounds are a dedicated append-only child table (mirroring Task history's own sha
 
 Blocking is real: `tasks.complete` is refused while any `active` Discussion has a `blocks` edge to that Task. A `deferred` Discussion does not block -- "we will get back to this" is distinct from "resolved."
 
+`open`/`reply` can also pose a structured choice instead of (or alongside) free text: `options` (2-10 entries) plus `options_mode` -- `single` is mutually exclusive (exactly one pick), `multi` allows several. The Discussion remembers the pending choice (`extra.discussion.pendingOptions`/`pendingOptionsMode`) until a `reply` answers it with `selected`, validated against exactly what was offered and the mode's cardinality; a reply can also pose the *next* round's choice in the same call.
+
+Run `/discuss` for the interactive panel: browse every Discussion (the real `active`/`deferred`/`settled` state shown per row, alongside any choice awaiting an answer), open a scrollable transcript showing what was posed and picked in each round, and reply/defer/resume/settle or block/unblock a task without leaving the TUI. Replying to a pending choice shows a real picker -- the native single-select list for `single`, or a checkbox multi-select (space to toggle, enter to confirm) for `multi`, since no built-in multi-select exists in the Pi extension UI. Opening a *new* Discussion is left to the agent (same as Docs/Rules/Skills) -- `/discuss` browses and drives existing ones.
+
 ```bash
 papyrus discuss open --title "Naming" --actor alice --content "Should we rename this?" --blocks-json '["task-id"]' --json
+papyrus discuss open --title "Which approach" --actor alice --content "Pick one" --options-json '["A","B"]' --options-mode single --json
 papyrus discuss reply <discussion-id> --actor bob --content "I think so, here's why..." --json
+papyrus discuss reply <discussion-id> --actor bob --content "Going with B" --selected-json '["B"]' --json
 papyrus discuss defer <discussion-id> --reason "Waiting on design review" --json
 papyrus discuss resume <discussion-id> --json
 papyrus discuss settle <discussion-id> --settlement "Agreed: renaming to X" --json

package/extension/src/artifact-status-presentation.ts

@@ -36,6 +36,19 @@ export const SKILL_STATUS_PRESENTATION: Record<string, StatusPresentation> = {
 	deprecated: { label: "deprecated", glyph: "○", color: "muted" },
 };
 
+/**
+ * Keyed by extra.discussion.state, not the shared Doc status column -- a settled Discussion's
+ * doc.status becomes "archived", but a deferred one stays "active" at the doc level (see
+ * domain/discussion.ts's header comment). Reusing DOC_STATUS_PRESENTATION here would render
+ * "deferred" and "active" Discussions with the identical glyph, silently losing the one piece
+ * of state this feature exists to distinguish.
+ */
+export const DISCUSSION_STATE_PRESENTATION: Record<string, StatusPresentation> = {
+	active: { label: "active", glyph: "●", color: "accent" },
+	deferred: { label: "deferred", glyph: "⏸", color: "warning" },
+	settled: { label: "settled", glyph: "✓", color: "success" },
+};
+
 /** Rule severity gets its own color independent of status -- block is the loudest, info the quietest. */
 export const RULE_SEVERITY_PRESENTATION: Record<string, ThemeColor> = {
 	block: "error",

package/extension/src/discuss.ts

@@ -0,0 +1,110 @@
+/**
+ * discuss.ts — /discuss interactive panel.
+ * Reuses the generic artifact browser (artifact-browser.ts), same as docs.ts/rules.ts/notes.ts:
+ * a Discussion is a `doc` artifact, so the browser's list/filter/refresh/select-action loop
+ * applies unchanged. The one real wrinkle is that Discuss's meaningful lifecycle state
+ * (active/deferred/settled) lives in extra.discussion, not the shared doc status column the
+ * browser colors its row glyph by (see artifact-status-presentation.ts's DISCUSSION_STATE_PRESENTATION
+ * comment) -- so the real state is surfaced in rowMeta text instead, the same way rules.ts
+ * surfaces severity and notes.ts surfaces history count, both also not the row glyph.
+ *
+ * Creating a new Discussion is left to the agent (the discuss tool), matching docs.ts/rules.ts/
+ * skills.ts precedent -- Notes is the one kind with a human-facing creation command (/note),
+ * because Notes exists specifically as a human-authored inbox.
+ */
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { Artifact } from "../../src/domain/artifact.ts";
+import type { DiscussionAndRounds } from "../../src/discussion-service.ts";
+import { readDiscussionExtra } from "../../src/domain/discussion.ts";
+import { showArtifactBrowser } from "./artifact-browser.ts";
+import { DISCUSSION_STATE_PRESENTATION, DOC_STATUS_PRESENTATION } from "./artifact-status-presentation.ts";
+import { discussionRoundCountOf, discussionStateOf, showDiscussionDetailView } from "./discussion-detail-view.ts";
+import { pickDiscussionOptions } from "./discussion-picker.ts";
+import { callService } from "./service-client.ts";
+
+const SOURCE = "discuss-tui";
+const ACTOR = "human";
+
+export function discussionRowMeta(discussion: Artifact, theme: Theme): string {
+	const state = discussionStateOf(discussion);
+	const presentation = DISCUSSION_STATE_PRESENTATION[state];
+	const stateText = presentation ? theme.fg(presentation.color, `${presentation.glyph} ${presentation.label}`) : theme.fg("muted", "state unknown");
+	const rounds = discussionRoundCountOf(discussion);
+	const pending = (() => { try { return readDiscussionExtra(discussion.extra).pendingOptions; } catch { return undefined; } })();
+	const pendingText = pending && pending.length > 0 ? theme.fg("accent", ` · awaiting: ${pending.join("/")}`) : "";
+	return `${stateText} · ${rounds} round${rounds === 1 ? "" : "s"}${pendingText}`;
+}
+
+function discussionActions(discussion: Artifact): string[] {
+	const state = discussionStateOf(discussion);
+	if (state === "active") return ["Show transcript", "Reply", "Defer", "Settle", "Block a task", "Unblock a task"];
+	if (state === "deferred") return ["Show transcript", "Resume", "Settle"];
+	return ["Show transcript"]; // settled, or an unrecognized/corrupt state -- read-only either way
+}
+
+export async function showDiscussions(ctx: ExtensionCommandContext): Promise<void> {
+	await showArtifactBrowser(ctx, {
+		kind: "doc",
+		title: "Discussions",
+		listOperation: "discuss.list",
+		statusOrder: ["draft", "active", "archived"],
+		presentation: DOC_STATUS_PRESENTATION,
+		rowMeta: discussionRowMeta,
+		actions: discussionActions,
+		handleAction: async (choice, discussion, commandCtx) => {
+			if (choice === "Show transcript") {
+				const result = await callService<Record<string, unknown>, DiscussionAndRounds>("discuss.show", { id: discussion.id });
+				await showDiscussionDetailView(commandCtx, result.discussion, result.rounds);
+				return;
+			}
+			if (choice === "Reply") {
+				const pending = (() => { try { return readDiscussionExtra(discussion.extra); } catch { return undefined; } })();
+				if (pending?.pendingOptions && pending.pendingOptions.length > 0 && pending.pendingOptionsMode) {
+					const selected = await pickDiscussionOptions(commandCtx, pending.pendingOptionsMode, pending.pendingOptions);
+					if (!selected) return; // canceled
+					const elaboration = await commandCtx.ui.input("Elaborate (optional):", selected.join(", "));
+					if (elaboration === undefined) return; // canceled
+					await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content: elaboration || selected.join(", "), selected, source: SOURCE });
+					commandCtx.ui.notify(`Selected: ${selected.join(", ")}`, "info");
+					return;
+				}
+				const content = await commandCtx.ui.input("Reply:", "");
+				if (!content) return;
+				await callService("discuss.reply", { id: discussion.id, actor: ACTOR, content, source: SOURCE });
+				commandCtx.ui.notify("Round added.", "info");
+				return;
+			}
+			if (choice === "Defer") {
+				const reason = await commandCtx.ui.input("Defer reason (optional):", "");
+				await callService("discuss.defer", { id: discussion.id, ...(reason ? { reason } : {}), actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify("Deferred.", "info");
+				return;
+			}
+			if (choice === "Resume") {
+				await callService("discuss.resume", { id: discussion.id, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify("Resumed.", "info");
+				return;
+			}
+			if (choice === "Settle") {
+				const settlement = await commandCtx.ui.input("Settlement:", "");
+				if (!settlement) return;
+				await callService("discuss.settle", { id: discussion.id, settlement, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify("Settled.", "info");
+				return;
+			}
+			if (choice === "Block a task") {
+				const taskId = await commandCtx.ui.input("Task artifact id to block:", "");
+				if (!taskId) return;
+				await callService("discuss.block", { id: discussion.id, task_id: taskId, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify(`${discussion.id} now blocks ${taskId}`, "info");
+				return;
+			}
+			if (choice === "Unblock a task") {
+				const taskId = await commandCtx.ui.input("Task artifact id to unblock:", "");
+				if (!taskId) return;
+				const result = await callService<Record<string, unknown>, { unblocked: boolean }>("discuss.unblock", { id: discussion.id, task_id: taskId, actor: ACTOR, source: SOURCE });
+				commandCtx.ui.notify(result.unblocked ? `${discussion.id} no longer blocks ${taskId}` : "No such blocking relationship.", "info");
+			}
+		},
+	});
+}

package/extension/src/discussion-detail-view.ts

@@ -0,0 +1,136 @@
+/**
+ * discussion-detail-view.ts — the transcript view for a single Discussion.
+ *
+ * The generic artifact detail view (artifact-detail-view.ts) formats an artifact's own
+ * fields (title, body, extra as JSON, edges); it has no way to show a Discussion's rounds,
+ * since those live in a dedicated child table fetched separately (discuss.show / discuss.rounds),
+ * not in the artifact row itself. Tasks needed the same kind of dedicated view for the same
+ * underlying reason (task-detail-view.ts) -- this mirrors that scrolling-viewport idiom rather
+ * than inventing a new one.
+ */
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, type TUI } from "@earendil-works/pi-tui";
+import {
+	ARTIFACT_DETAIL_MAX_VISIBLE_LINES,
+	ARTIFACT_DETAIL_MIN_VISIBLE_LINES,
+	ARTIFACT_DETAIL_RESERVED_ROWS,
+} from "../../src/constants.ts";
+import type { Artifact } from "../../src/domain/artifact.ts";
+import { readDiscussionExtra, type DiscussionRound } from "../../src/domain/discussion.ts";
+import { renderMarkdownBody, type ActiveTheme } from "./markdown.ts";
+import { DISCUSSION_STATE_PRESENTATION } from "./artifact-status-presentation.ts";
+
+interface TranscriptLine {
+	text: string;
+}
+
+/** Reads state defensively for display -- a corrupt/foreign extra.discussion shape shows as "unknown" rather than crashing the whole panel over one bad row. */
+export function discussionStateOf(discussion: Artifact): string {
+	try {
+		return readDiscussionExtra(discussion.extra).state;
+	} catch {
+		return "unknown";
+	}
+}
+
+export function discussionRoundCountOf(discussion: Artifact): number {
+	try {
+		return readDiscussionExtra(discussion.extra).roundCount;
+	} catch {
+		return 0;
+	}
+}
+
+class DiscussionTranscriptViewport {
+	private offsetY = 0;
+	private renderedWidth = 0;
+	private lines: TranscriptLine[] = [];
+	private readonly visibleLines: number;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly activeTheme: ActiveTheme,
+		private readonly discussion: Artifact,
+		private readonly rounds: DiscussionRound[],
+		private readonly close: () => void,
+	) {
+		this.visibleLines = Math.max(
+			ARTIFACT_DETAIL_MIN_VISIBLE_LINES,
+			Math.min(ARTIFACT_DETAIL_MAX_VISIBLE_LINES, tui.terminal.rows - ARTIFACT_DETAIL_RESERVED_ROWS),
+		);
+	}
+
+	invalidate(): void { this.renderedWidth = 0; }
+
+	render(width: number): string[] {
+		const contentWidth = Math.max(1, width - 2);
+		this.buildLines(contentWidth);
+		this.offsetY = Math.min(this.offsetY, Math.max(0, this.lines.length - this.visibleLines));
+		const end = Math.min(this.lines.length, this.offsetY + this.visibleLines);
+		const theme = this.activeTheme();
+		const border = theme.fg("borderMuted", "─".repeat(Math.max(1, width)));
+		const footer = [
+			this.lines.length > this.visibleLines ? `↑/↓ scroll · ${this.offsetY + 1}-${end}/${this.lines.length}` : "",
+			"Esc back",
+		].filter(Boolean).join(" · ");
+		return [
+			border,
+			truncateToWidth(theme.fg("accent", theme.bold("Discussion transcript")), width, ""),
+			border,
+			...this.lines.slice(this.offsetY, end).map((line) => truncateToWidth(` ${line.text}`, width, "")),
+			truncateToWidth(theme.fg("dim", footer), width, ""),
+			border,
+		];
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.close(); return; }
+		if (matchesKey(data, "up")) this.offsetY = Math.max(0, this.offsetY - 1);
+		else if (matchesKey(data, "down")) this.offsetY = Math.min(Math.max(0, this.lines.length - this.visibleLines), this.offsetY + 1);
+		else if (matchesKey(data, "pageDown")) this.offsetY = Math.min(Math.max(0, this.lines.length - this.visibleLines), this.offsetY + this.visibleLines);
+		else if (matchesKey(data, "pageUp")) this.offsetY = Math.max(0, this.offsetY - this.visibleLines);
+		else return;
+		this.tui.requestRender();
+	}
+
+	private buildLines(width: number): void {
+		if (this.renderedWidth === width) return;
+		this.renderedWidth = width;
+		const theme = this.activeTheme();
+		const extra = (() => { try { return readDiscussionExtra(this.discussion.extra); } catch { return undefined; } })();
+		const presentation = extra ? DISCUSSION_STATE_PRESENTATION[extra.state] : undefined;
+		const stateLine = presentation
+			? theme.fg(presentation.color, `${presentation.glyph} ${presentation.label}`)
+			: theme.fg("muted", "state unknown");
+		const header: TranscriptLine[] = [
+			{ text: theme.bold(this.discussion.title) },
+			{ text: `${stateLine}${theme.fg("dim", ` · ${this.discussion.id}`)}` },
+			...(extra?.deferredReason ? [{ text: theme.fg("muted", `Deferred: ${extra.deferredReason}`) }] : []),
+			...(extra?.settlement ? [{ text: theme.fg("success", `Settled: ${extra.settlement}`) }] : []),
+			{ text: "" },
+		];
+		const transcript: TranscriptLine[] = this.rounds.flatMap((round, index) => {
+			const roundHeader = theme.fg("accent", `[round ${round.roundNumber}] `) + theme.bold(round.actor) + theme.fg("dim", ` · ${round.occurredAt}`);
+			const body = renderMarkdownBody(round.content, width - 2, this.activeTheme).map((line) => ({ text: `  ${line}` }));
+			const posed = round.options && round.options.length > 0
+				? [{ text: `  ${theme.fg("muted", `Posed (${round.optionsMode === "multi" ? "pick several" : "pick one"}): ${round.options.join(", ")}`)}` }]
+				: [];
+			const picked = round.selected && round.selected.length > 0
+				? [{ text: `  ${theme.fg("success", `Selected: ${round.selected.join(", ")}`)}` }]
+				: [];
+			return [{ text: roundHeader }, ...body, ...posed, ...picked, ...(index < this.rounds.length - 1 ? [{ text: "" }] : [])];
+		});
+		this.lines = [...header, ...(transcript.length > 0 ? transcript : [{ text: theme.fg("muted", "No rounds recorded.") }])];
+		this.offsetY = Math.min(this.offsetY, Math.max(0, this.lines.length - this.visibleLines));
+	}
+}
+
+export async function showDiscussionDetailView(ctx: ExtensionCommandContext, discussion: Artifact, rounds: DiscussionRound[]): Promise<void> {
+	if (ctx.mode !== "tui") {
+		const lines = rounds.map((round) => `[round ${round.roundNumber}] ${round.actor}: ${round.content}`);
+		ctx.ui.notify([discussion.title, ...lines].join("\n"), "info");
+		return;
+	}
+	await ctx.ui.custom<void>((tui, theme, _keybindings, done) =>
+		new DiscussionTranscriptViewport(tui, () => ctx.ui.theme ?? theme, discussion, rounds, done));
+}

package/extension/src/discussion-picker.ts

@@ -0,0 +1,59 @@
+/**
+ * discussion-picker.ts — the structured-choice picker for /discuss's "Reply" action.
+ *
+ * "single" mode (mutually exclusive) needs nothing bespoke: the Pi extension UI already
+ * provides exactly that (ctx.ui.select). "multi" (allow several) has no native equivalent
+ * anywhere in @earendil-works/pi-coding-agent or pi-tui (checked both) -- so this is a small,
+ * genuinely domain-specific checkbox-list component, not a generic library replacement.
+ */
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { DiscussionOptionsMode } from "../../src/domain/discussion.ts";
+
+/** Toggle with space, confirm with enter (refuses an empty confirm -- at least one pick is required), cancel with escape. */
+async function pickMultiple(ctx: ExtensionCommandContext, title: string, options: string[]): Promise<string[] | undefined> {
+	return ctx.ui.custom<string[] | undefined>((tui, theme, _keybindings, done) => {
+		const checked = new Set<number>();
+		let selectedIndex = 0;
+		return {
+			invalidate() {},
+			render(width: number): string[] {
+				const lines: string[] = [
+					theme.bold(title),
+					theme.fg("muted", "space toggle \u00b7 enter confirm \u00b7 esc cancel"),
+					"",
+				];
+				options.forEach((option, index) => {
+					const cursor = index === selectedIndex ? theme.fg("accent", "\u276f") : " ";
+					const box = checked.has(index) ? theme.fg("success", "[x]") : "[ ]";
+					const label = index === selectedIndex ? theme.bold(option) : option;
+					lines.push(truncateToWidth(`${cursor} ${box} ${label}`, width, ""));
+				});
+				lines.push("");
+				lines.push(theme.fg("dim", `${checked.size} selected`));
+				return lines;
+			},
+			handleInput(data: string) {
+				if (matchesKey(data, "up")) selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+				else if (matchesKey(data, "down")) selectedIndex = (selectedIndex + 1) % options.length;
+				else if (data === " ") { if (checked.has(selectedIndex)) checked.delete(selectedIndex); else checked.add(selectedIndex); }
+				else if (matchesKey(data, "enter")) {
+					if (checked.size === 0) return; // refuse an empty confirm -- selecting nothing isn't a valid answer
+					done([...checked].sort((a, b) => a - b).map((index) => options[index]!));
+					return;
+				} else if (matchesKey(data, "escape")) { done(undefined); return; }
+				else return;
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+/** Picks one (single) or several (multi) of the given options, or undefined if the user cancels. */
+export async function pickDiscussionOptions(ctx: ExtensionCommandContext, mode: DiscussionOptionsMode, options: string[]): Promise<string[] | undefined> {
+	if (mode === "single") {
+		const pick = await ctx.ui.select("Pick one:", options);
+		return pick ? [pick] : undefined;
+	}
+	return pickMultiple(ctx, "Pick one or more:", options);
+}

package/extension/src/domain-tools.ts

@@ -438,7 +438,7 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "discuss",
 		label: "Discuss",
-		description: "Native Papyrus deliberation with a real lifecycle -- distinct from a one-shot ask: a Discussion persists, takes multiple rounds, and can genuinely block a Task's completion until settled or deferred. ACTIONS: open, reply, defer, resume, settle, block, unblock, show, rounds, list. open starts round 1 and optionally blocks_task_ids immediately. reply is refused once deferred or settled -- resume first. defer is explicitly non-blocking (paused, resumable); settle is terminal and archives the discussion. block/unblock manage the blocking relationship to a task independently of open. A task's completion is refused while any active Discussion blocks it.",
+		description: "Native Papyrus deliberation with a real lifecycle -- distinct from a one-shot ask: a Discussion persists, takes multiple rounds, and can genuinely block a Task's completion until settled or deferred. ACTIONS: open, reply, defer, resume, settle, block, unblock, show, rounds, list. open starts round 1 and optionally blocks_task_ids immediately. reply is refused once deferred or settled -- resume first. defer is explicitly non-blocking (paused, resumable); settle is terminal and archives the discussion. block/unblock manage the blocking relationship to a task independently of open. A task's completion is refused while any active Discussion blocks it. open/reply can pose a structured choice via options (2-10 entries) + options_mode ('single' mutually exclusive, 'multi' allows several); reply answers a currently pending choice via selected, validated against it.",
 		parameters: Type.Object({
 			action: Type.String(),
 			id: Type.Optional(Type.String()),
@@ -454,6 +454,9 @@ export function registerDomainTools(pi: ExtensionAPI): void {
 			state: Type.Optional(Type.String()),
 			after_round: Type.Optional(Type.Number()),
 			limit: Type.Optional(Type.Number()),
+			options: Type.Optional(Type.Array(Type.String())),
+			options_mode: Type.Optional(Type.String()),
+			selected: Type.Optional(Type.Array(Type.String())),
 		}),
 		renderCall(args, theme) { return renderPapyrusToolCall("Discuss", args, theme); },
 		renderResult(result, options, theme, context) { return renderPapyrusToolResult(result, options, theme, context); },

package/extension/src/index.ts

@@ -416,12 +416,13 @@ export default async function (pi: ExtensionAPI) {
 	// ── Interactive artifact browsers ──────────────────────────────────
 
 	// Lazy imports keep TUI components out of non-interactive startup paths.
-	const [tasksModule, docsModule, notesModule, rulesModule, skillsModule] = await Promise.all([
+	const [tasksModule, docsModule, notesModule, rulesModule, skillsModule, discussModule] = await Promise.all([
 		import("./tasks.ts"),
 		import("./docs.ts"),
 		import("./notes.ts"),
 		import("./rules.ts"),
 		import("./skills.ts"),
+		import("./discuss.ts"),
 	]);
 	let overlay: TaskOverlay | undefined;
 
@@ -454,6 +455,10 @@ export default async function (pi: ExtensionAPI) {
 		description: "Browse and invoke Papyrus skills and templates (interactive)",
 		handler: async (_args, ctx) => { await skillsModule.showSkills(ctx); },
 	});
+	pi.registerCommand("discuss", {
+		description: "Browse Papyrus Discussions and reply, defer, resume, settle, or block/unblock a task (interactive)",
+		handler: async (_args, ctx) => { await discussModule.showDiscussions(ctx); },
+	});
 	pi.registerCommand("context", {
 		description: "Structured, per-segment breakdown of the context window: real usage against the model's window, drilling into Papyrus Rules and the Pi-native skill catalog",
 		handler: async (_args, ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/adapters/sqlite-discussion-round-store.ts

@@ -1,6 +1,14 @@
 import type { Db } from "../db.ts";
 import { DISCUSSION_ROUNDS_DEFAULT_LIMIT, DISCUSSION_ROUNDS_MAX_LIMIT } from "../constants.ts";
-import { validateDiscussionActor, validateDiscussionContent, type AppendDiscussionRound, type DiscussionRound, type DiscussionRoundQuery } from "../domain/discussion.ts";
+import {
+	validateDiscussionActor,
+	validateDiscussionContent,
+	validateDiscussionOptions,
+	type AppendDiscussionRound,
+	type DiscussionOptionsMode,
+	type DiscussionRound,
+	type DiscussionRoundQuery,
+} from "../domain/discussion.ts";
 import type { DiscussionRoundStore } from "../ports/discussion-round-store.ts";
 
 interface DiscussionRoundRow {
@@ -10,6 +18,9 @@ interface DiscussionRoundRow {
 	actor: string;
 	content: string;
 	occurred_at: string;
+	options: string | null;
+	options_mode: string | null;
+	selected: string | null;
 }
 
 function mapRow(row: DiscussionRoundRow): DiscussionRound {
@@ -20,6 +31,9 @@ function mapRow(row: DiscussionRoundRow): DiscussionRound {
 		actor: row.actor,
 		content: row.content,
 		occurredAt: row.occurred_at,
+		...(row.options !== null ? { options: JSON.parse(row.options) as string[] } : {}),
+		...(row.options_mode !== null ? { optionsMode: row.options_mode as DiscussionOptionsMode } : {}),
+		...(row.selected !== null ? { selected: JSON.parse(row.selected) as string[] } : {}),
 	};
 }
 
@@ -29,10 +43,21 @@ export class SQLiteDiscussionRoundStore implements DiscussionRoundStore {
 	append(round: AppendDiscussionRound, occurredAt: string): DiscussionRound {
 		const content = validateDiscussionContent(round.content);
 		const actor = validateDiscussionActor(round.actor);
+		// selected isn't validated here -- it requires cross-referencing the Discussion's
+		// currently pending options (extra.discussion), which this store, deliberately scoped to
+		// the rounds table alone, has no access to. discussion-service.ts validates it beforehand.
+		const posed = round.options !== undefined || round.optionsMode !== undefined
+			? validateDiscussionOptions(round.options ?? [], round.optionsMode ?? "")
+			: undefined;
 		const result = this.db.prepare(`
-			INSERT INTO discussion_rounds (discussion_id, round_number, actor, content, occurred_at, event_schema_version)
-			VALUES (?, ?, ?, ?, ?, 1)
-		`).run(round.discussionId, round.roundNumber, actor, content, occurredAt);
+			INSERT INTO discussion_rounds (discussion_id, round_number, actor, content, occurred_at, event_schema_version, options, options_mode, selected)
+			VALUES (?, ?, ?, ?, ?, 1, ?, ?, ?)
+		`).run(
+			round.discussionId, round.roundNumber, actor, content, occurredAt,
+			posed ? JSON.stringify(posed.options) : null,
+			posed ? posed.mode : null,
+			round.selected !== undefined ? JSON.stringify(round.selected) : null,
+		);
 		return {
 			id: Number(result.lastInsertRowid),
 			discussionId: round.discussionId,
@@ -40,13 +65,15 @@ export class SQLiteDiscussionRoundStore implements DiscussionRoundStore {
 			actor,
 			content,
 			occurredAt,
+			...(posed ? { options: posed.options, optionsMode: posed.mode } : {}),
+			...(round.selected !== undefined ? { selected: [...round.selected] } : {}),
 		};
 	}
 
 	list(query: DiscussionRoundQuery): DiscussionRound[] {
 		const limit = Math.min(DISCUSSION_ROUNDS_MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DISCUSSION_ROUNDS_DEFAULT_LIMIT)));
 		const rows = this.db.prepare(`
-			SELECT id, discussion_id, round_number, actor, content, occurred_at
+			SELECT id, discussion_id, round_number, actor, content, occurred_at, options, options_mode, selected
 			FROM discussion_rounds
 			WHERE discussion_id = ? AND round_number > ?
 			ORDER BY round_number ASC

package/src/cli.ts

@@ -118,8 +118,8 @@ const USAGE = `Usage:
   papyrus log append --source <id> --level <debug|info|warning|error> --message <text> --operation-id <id> [--source-label <text>] [--fields-json <json>] [--session-id <id>] [--occurred-at <iso>] [--global] [--json]
   papyrus session register --session-id <id> [--json]
   papyrus session release --session-id <id> [--session-secret <secret>] [--json]
-  papyrus discuss open --title <t> --actor <a> --content <c> [--body <b>] [--labels-json <json>] [--blocks-json <json>] [--json]
-  papyrus discuss reply <id> --actor <a> --content <c> [--json]
+  papyrus discuss open --title <t> --actor <a> --content <c> [--body <b>] [--labels-json <json>] [--blocks-json <json>] [--options-json <json>] [--options-mode single|multi] [--json]
+  papyrus discuss reply <id> --actor <a> --content <c> [--selected-json <json>] [--options-json <json>] [--options-mode single|multi] [--json]
   papyrus discuss defer <id> [--reason <text>] [--json]
   papyrus discuss resume <id> [--json]
   papyrus discuss settle <id> --settlement <text> [--json]
@@ -999,6 +999,9 @@ export async function runDiscussCli(args: string[], client: TaskCliClient): Prom
 	let state: string | undefined;
 	let afterRound: number | undefined;
 	let limit: number | undefined;
+	let options: string[] | undefined;
+	let optionsMode: string | undefined;
+	let selected: string[] | undefined;
 	for (let index = 0; index < args.length; index++) {
 		const argument = args[index]!;
 		if (argument === "--json") continue;
@@ -1009,6 +1012,9 @@ export async function runDiscussCli(args: string[], client: TaskCliClient): Prom
 		if (argument === "--labels-json") { labels = parseJsonStringArrayFlag(args[++index], "--labels-json"); continue; }
 		if (argument === "--blocks-json") { blocksTaskIds = parseJsonStringArrayFlag(args[++index], "--blocks-json"); continue; }
 		if (argument === "--task-id") { taskId = args[++index]; if (!taskId) throw new Error("--task-id requires a value"); continue; }
+		if (argument === "--options-json") { options = parseJsonStringArrayFlag(args[++index], "--options-json"); continue; }
+		if (argument === "--options-mode") { optionsMode = args[++index]; if (!optionsMode) throw new Error("--options-mode requires a value"); continue; }
+		if (argument === "--selected-json") { selected = parseJsonStringArrayFlag(args[++index], "--selected-json"); continue; }
 		if (argument === "--reason") { reason = args[++index]; if (reason === undefined) throw new Error("--reason requires a value"); continue; }
 		if (argument === "--settlement") { settlement = args[++index]; if (!settlement) throw new Error("--settlement requires a value"); continue; }
 		if (argument === "--state") { state = args[++index]; if (!state) throw new Error("--state requires a value"); continue; }
@@ -1031,12 +1037,12 @@ export async function runDiscussCli(args: string[], client: TaskCliClient): Prom
 	switch (action) {
 		case "open": {
 			if (id) throw new Error("discuss open accepts no positional arguments");
-			const result = await client.call<Record<string, unknown>, unknown>("discuss.open", { title, actor, content, body, labels, blocks_task_ids: blocksTaskIds });
+			const result = await client.call<Record<string, unknown>, unknown>("discuss.open", { title, actor, content, body, labels, blocks_task_ids: blocksTaskIds, options, options_mode: optionsMode });
 			return json ? JSON.stringify(result) : JSON.stringify(result, null, 2);
 		}
 		case "reply": {
 			if (!id) throw new Error("discuss reply requires exactly one discussion id");
-			const result = await client.call<Record<string, unknown>, unknown>("discuss.reply", { id, actor, content });
+			const result = await client.call<Record<string, unknown>, unknown>("discuss.reply", { id, actor, content, selected, options, options_mode: optionsMode });
 			return json ? JSON.stringify(result) : JSON.stringify(result, null, 2);
 		}
 		case "defer": {

package/src/constants.ts

@@ -7,7 +7,7 @@ export const DAEMON_PROBE_TIMEOUT_MS = 800;
 export const DAEMON_UNIT_NAME = "papyrus.service";
 export const DAEMON_DIR_ENV = "PAPYRUS_DAEMON_DIR";
 export const SQLITE_BUSY_TIMEOUT_MS = 5_000;
-export const SQLITE_SCHEMA_VERSION = 15;
+export const SQLITE_SCHEMA_VERSION = 16;
 export const SERVICE_MAX_BODY_BYTES = 1_048_576;
 
 export const WAL_CHECKPOINT_INTERVAL_MS = 60_000;
@@ -158,6 +158,14 @@ export const DISCUSSION_LIST_MAX_LIMIT = 200;
 export const DISCUSSION_SETTLEMENT_MAX_CHARACTERS = 4_000;
 export const DISCUSSION_DEFER_REASON_MAX_CHARACTERS = 2_000;
 export const DISCUSSION_ACTOR_MAX_LENGTH = 128;
+/**
+ * A posed choice (open/reply with options): "single" is mutually exclusive (exactly one pick),
+ * "multi" allows several. Mirrors opencode's QuestionV2 labeled-multiple-choice model (the one
+ * piece of prior art surveyed that already solves this), kept native and dependency-free here.
+ */
+export const DISCUSSION_OPTIONS_MIN_COUNT = 2;
+export const DISCUSSION_OPTIONS_MAX_COUNT = 10;
+export const DISCUSSION_OPTION_MAX_LENGTH = 200;
 /** Bounds for the generic graph projection protocol (external bounded contexts). */
 export const GRAPH_PROJECTION_MAX_ARTIFACTS_PER_BATCH = 500;
 export const GRAPH_PROJECTION_MAX_EDGES_PER_BATCH = 1_000;

package/src/db.ts

@@ -235,6 +235,9 @@ CREATE TABLE IF NOT EXISTS discussion_rounds (
 	content       TEXT NOT NULL,
 	occurred_at   TEXT NOT NULL,
 	event_schema_version INTEGER NOT NULL DEFAULT 1,
+	options       TEXT,
+	options_mode  TEXT,
+	selected      TEXT,
 	UNIQUE (discussion_id, round_number)
 );
 CREATE INDEX IF NOT EXISTS discussion_rounds_discussion_idx ON discussion_rounds(discussion_id, round_number, id);
@@ -323,6 +326,7 @@ const CORE_LEDGER_VERSIONS: ReadonlyArray<{ version: number; name: string; check
 	{ version: 5, name: "session-identity", checksum: "1c6a165bbe37f82a100fd34762db70c3f8ab15ff20c3a53c2e60448edc815a5e" },
 	{ version: 6, name: "artifact-trash", checksum: "4a75dbec2892deb54bcc1afdf0d51d81f03a8d10861787d083784a29e5c7e8f9" },
 	{ version: 7, name: "discuss-native", checksum: "ab7bdd04824bd93681917807b817d6e08b9825af90161e3ccd6d6663021dc6a0" },
+	{ version: 8, name: "discuss-options", checksum: "ba1fc5ab7cfe9166d71cc1842f13bc32a0905d08696006cec202196a70c832e8" },
 ];
 
 export function migrationLedger(db: Db): ModuleMigrationRow[] {
@@ -470,6 +474,22 @@ const FUTURE_MIGRATIONS: ReadonlyArray<PapyrusMigration> = [
 			`);
 		},
 	},
+	{
+		version: 16,
+		name: "discuss-options",
+		// See domain/discussion.ts. Nullable, purely additive columns: a round with no posed choice
+		// (the overwhelming majority, before this feature existed) simply stores NULL in all three.
+		// Guarded per-column (SQLite has no `ADD COLUMN IF NOT EXISTS`): a fixture that bootstraps
+		// from the CURRENT SCHEMA text (which already declares these columns) and then only fakes an
+		// older user_version to exercise this migration path must not fail with "duplicate column
+		// name" -- the same class of already-bootstrapped-fixture concern version 9's comment covers.
+		up: (db) => {
+			const existing = new Set((db.prepare("PRAGMA table_info(discussion_rounds)").all() as Array<{ name: string }>).map((row) => row.name));
+			for (const column of ["options", "options_mode", "selected"]) {
+				if (!existing.has(column)) db.exec(`ALTER TABLE discussion_rounds ADD COLUMN ${column} TEXT`);
+			}
+		},
+	},
 ];
 
 /**

package/src/discussion-service.ts

@@ -3,7 +3,7 @@
  * append-only rounds (via DiscussionRoundStore). See domain/discussion.ts for the full
  * design rationale.
  */
-import { DISCUSSION_MAX_ROUNDS } from "./constants.ts";
+import { DISCUSSION_LIST_DEFAULT_LIMIT, DISCUSSION_LIST_MAX_LIMIT, DISCUSSION_MAX_ROUNDS } from "./constants.ts";
 import {
 	DISCUSSION_SUBTYPE,
 	isDiscussionArtifact,
@@ -11,8 +11,11 @@ import {
 	validateDeferReason,
 	validateDiscussionActor,
 	validateDiscussionContent,
+	validateDiscussionOptions,
+	validateSelectedOptions,
 	validateSettlement,
 	type DiscussionExtra,
+	type DiscussionOptionsMode,
 	type DiscussionRound,
 } from "./domain/discussion.ts";
 import type { Artifact } from "./domain/artifact.ts";
@@ -29,7 +32,19 @@ export interface OpenDiscussionInput {
 	body?: string;
 	labels?: string[];
 	blocksTaskIds?: string[];
-	projectRoot?: string;
+	/** Poses a choice on round 1 -- both or neither; see domain/discussion.ts's DiscussionOptionsMode. */
+	options?: string[];
+	optionsMode?: DiscussionOptionsMode;
+}
+
+export interface ReplyInput {
+	actor: string;
+	content: string;
+	/** Answers the Discussion's currently pending posed choice, if any; validated against it. */
+	selected?: string[];
+	/** Poses a new choice on this same round, replacing whatever was previously pending. */
+	options?: string[];
+	optionsMode?: DiscussionOptionsMode;
 }
 
 export interface DiscussionAndRounds {
@@ -53,9 +68,16 @@ export class Discussions {
 		return readDiscussionExtra(discussion.extra);
 	}
 
+	/** Validates a freshly-posed choice; undefined when neither field is given (nothing posed), since both/neither is the only valid shape. */
+	private validatePosedOptions(options: string[] | undefined, optionsMode: DiscussionOptionsMode | undefined): { options: string[]; mode: DiscussionOptionsMode } | undefined {
+		if (options === undefined && optionsMode === undefined) return undefined;
+		return validateDiscussionOptions(options ?? [], optionsMode ?? "");
+	}
+
 	open(input: OpenDiscussionInput, context?: ArtifactEventContext): DiscussionAndRounds {
 		const actor = validateDiscussionActor(input.actor);
 		const content = validateDiscussionContent(input.content);
+		const posed = this.validatePosedOptions(input.options, input.optionsMode);
 		return this.artifacts.atomic(() => {
 			const discussion = this.artifacts.create({
 				kind: "doc",
@@ -64,25 +86,46 @@ export class Discussions {
 				body: input.body ?? "",
 				status: "active",
 				labels: input.labels,
-				extra: { discussion: { state: "active", roundCount: 1 } },
+				extra: {
+					discussion: {
+						state: "active",
+						roundCount: 1,
+						...(posed ? { pendingOptions: posed.options, pendingOptionsMode: posed.mode } : {}),
+					},
+				},
 			}, context);
-			const round = this.rounds.append({ discussionId: discussion.id, roundNumber: 1, actor, content }, new Date().toISOString());
+			const round = this.rounds.append({
+				discussionId: discussion.id, roundNumber: 1, actor, content,
+				...(posed ? { options: posed.options, optionsMode: posed.mode } : {}),
+			}, new Date().toISOString());
 			for (const taskId of input.blocksTaskIds ?? []) this.block(discussion.id, taskId, context);
 			return { discussion: this.artifacts.get(discussion.id)!, rounds: [round] };
 		});
 	}
 
-	reply(discussionId: string, actor: string, content: string, context?: ArtifactEventContext): DiscussionAndRounds {
-		const validActor = validateDiscussionActor(actor);
-		const validContent = validateDiscussionContent(content);
+	reply(discussionId: string, input: ReplyInput, context?: ArtifactEventContext): DiscussionAndRounds {
+		const validActor = validateDiscussionActor(input.actor);
+		const validContent = validateDiscussionContent(input.content);
+		const posed = this.validatePosedOptions(input.options, input.optionsMode);
 		return this.artifacts.atomic(() => {
 			const discussion = requireDiscussion(this.artifacts.get(discussionId), discussionId);
 			const state = this.extra(discussion);
 			if (state.state !== "active") throw new DiscussionError(`discussion "${discussionId}" is ${state.state}; resume it before replying`);
 			if (state.roundCount >= DISCUSSION_MAX_ROUNDS) throw new DiscussionError(`discussion "${discussionId}" has reached its ${DISCUSSION_MAX_ROUNDS}-round limit; settle or defer it`);
+			const selected = input.selected !== undefined ? validateSelectedOptions(input.selected, state.pendingOptions, state.pendingOptionsMode) : undefined;
 			const nextRound = state.roundCount + 1;
-			const round = this.rounds.append({ discussionId, roundNumber: nextRound, actor: validActor, content: validContent }, new Date().toISOString());
-			const updated = this.artifacts.setExtra(discussionId, { ...discussion.extra, discussion: { ...state, roundCount: nextRound } }, context)!;
+			const round = this.rounds.append({
+				discussionId, roundNumber: nextRound, actor: validActor, content: validContent,
+				...(posed ? { options: posed.options, optionsMode: posed.mode } : {}),
+				...(selected ? { selected } : {}),
+			}, new Date().toISOString());
+			const { pendingOptions: _clearedOptions, pendingOptionsMode: _clearedMode, ...answered } = state;
+			const nextState = {
+				...(selected ? answered : state),
+				roundCount: nextRound,
+				...(posed ? { pendingOptions: posed.options, pendingOptionsMode: posed.mode } : {}),
+			};
+			const updated = this.artifacts.setExtra(discussionId, { ...discussion.extra, discussion: nextState }, context)!;
 			return { discussion: updated, rounds: [round] };
 		});
 	}
@@ -150,7 +193,11 @@ export class Discussions {
 	}
 
 	list(filter: { state?: string; limit?: number } = {}): Artifact[] {
-		const rows = this.artifacts.query({ kind: "doc", subtype: DISCUSSION_SUBTYPE, limit: filter.limit });
+		// DISCUSSION_LIST_MAX_LIMIT/DEFAULT_LIMIT exist specifically so an unqualified discuss.list
+		// (limit omitted) can never fall through to queryArtifacts' own unbounded default -- the same
+		// class of gap notes.ts's noteListInput comment documents fixing for Notes.
+		const limit = Math.min(DISCUSSION_LIST_MAX_LIMIT, Math.max(1, Math.floor(filter.limit ?? DISCUSSION_LIST_DEFAULT_LIMIT)));
+		const rows = this.artifacts.query({ kind: "doc", subtype: DISCUSSION_SUBTYPE, limit });
 		if (!filter.state) return rows;
 		return rows.filter((row) => {
 			try { return this.extra(row).state === filter.state; } catch { return false; }

package/src/domain/discussion.ts

@@ -17,6 +17,9 @@
 import {
 	DISCUSSION_ACTOR_MAX_LENGTH,
 	DISCUSSION_DEFER_REASON_MAX_CHARACTERS,
+	DISCUSSION_OPTION_MAX_LENGTH,
+	DISCUSSION_OPTIONS_MAX_COUNT,
+	DISCUSSION_OPTIONS_MIN_COUNT,
 	DISCUSSION_ROUND_CONTENT_MAX_CHARACTERS,
 	DISCUSSION_SETTLEMENT_MAX_CHARACTERS,
 } from "../constants.ts";
@@ -26,16 +29,26 @@ export const DISCUSSION_SUBTYPE = "discussion";
 export const DISCUSSION_STATES = ["active", "deferred", "settled"] as const;
 export type DiscussionState = typeof DISCUSSION_STATES[number];
 
-/** Persisted in a discussion Doc's `extra.discussion`. */
+/**
+ * A round can pose a choice (options + optionsMode) the way opencode's QuestionV2 poses
+ * labeled multiple-choice options, or answer one (selected). "single" is mutually exclusive
+ * (exactly one pick); "multi" allows several -- see constants.ts.
+ */
+export const DISCUSSION_OPTIONS_MODES = ["single", "multi"] as const;
+export type DiscussionOptionsMode = typeof DISCUSSION_OPTIONS_MODES[number];
+
+/** Persisted in a discussion Doc's `extra.discussion`. pendingOptions/-Mode is the current-state cache of "is there an unanswered posed choice right now" -- cleared once answered, set again whenever a round poses a new one. */
 export interface DiscussionExtra {
 	state: DiscussionState;
 	roundCount: number;
 	deferredReason?: string;
 	settlement?: string;
 	settledAt?: string;
+	pendingOptions?: string[];
+	pendingOptionsMode?: DiscussionOptionsMode;
 }
 
-/** One append-only round of a Discussion -- opening statement is round 1. */
+/** One append-only round of a Discussion -- opening statement is round 1. options/optionsMode/selected are the historical record of what was posed/picked in this specific round (extra.discussion.pendingOptions is the separate, mutable "what's unanswered right now" cache). */
 export interface DiscussionRound {
 	id: number;
 	discussionId: string;
@@ -43,6 +56,9 @@ export interface DiscussionRound {
 	actor: string;
 	content: string;
 	occurredAt: string;
+	options?: string[];
+	optionsMode?: DiscussionOptionsMode;
+	selected?: string[];
 }
 
 export interface AppendDiscussionRound {
@@ -50,6 +66,9 @@ export interface AppendDiscussionRound {
 	roundNumber: number;
 	actor: string;
 	content: string;
+	options?: string[];
+	optionsMode?: DiscussionOptionsMode;
+	selected?: string[];
 }
 
 export interface DiscussionRoundQuery {
@@ -79,6 +98,32 @@ export function validateSettlement(settlement: string): string {
 	return boundedString(settlement, "settlement", DISCUSSION_SETTLEMENT_MAX_CHARACTERS);
 }
 
+/** Validates a freshly-posed choice: 2..DISCUSSION_OPTIONS_MAX_COUNT unique, bounded-length options and a real mode. */
+export function validateDiscussionOptions(options: string[], mode: string): { options: string[]; mode: DiscussionOptionsMode } {
+	if (!(DISCUSSION_OPTIONS_MODES as readonly string[]).includes(mode)) {
+		throw new Error(`options_mode must be one of ${DISCUSSION_OPTIONS_MODES.join(", ")}`);
+	}
+	if (options.length < DISCUSSION_OPTIONS_MIN_COUNT || options.length > DISCUSSION_OPTIONS_MAX_COUNT) {
+		throw new Error(`options must have between ${DISCUSSION_OPTIONS_MIN_COUNT} and ${DISCUSSION_OPTIONS_MAX_COUNT} entries`);
+	}
+	for (const option of options) boundedString(option, "option", DISCUSSION_OPTION_MAX_LENGTH);
+	if (new Set(options).size !== options.length) throw new Error("options must not repeat an entry");
+	return { options: [...options], mode: mode as DiscussionOptionsMode };
+}
+
+/** Validates an answer against the Discussion's currently pending posed choice, if any. */
+export function validateSelectedOptions(selected: string[], pendingOptions: string[] | undefined, pendingMode: DiscussionOptionsMode | undefined): string[] {
+	if (!pendingOptions || pendingOptions.length === 0 || !pendingMode) {
+		throw new Error("this Discussion has no pending options to select from");
+	}
+	if (selected.length === 0) throw new Error("selected must not be empty");
+	if (new Set(selected).size !== selected.length) throw new Error("selected must not repeat an option");
+	const unknown = selected.filter((entry) => !pendingOptions.includes(entry));
+	if (unknown.length > 0) throw new Error(`selected option(s) not offered: ${unknown.join(", ")}`);
+	if (pendingMode === "single" && selected.length > 1) throw new Error('this Discussion\'s pending options are "single": pick exactly one');
+	return [...selected];
+}
+
 /** True for any artifact (already fetched) that is a Discussion, regardless of its current lifecycle state. */
 export function isDiscussionArtifact(artifact: { kind: string; subtype: string }): boolean {
 	return artifact.kind === "doc" && artifact.subtype === DISCUSSION_SUBTYPE;
@@ -97,11 +142,21 @@ export function readDiscussionExtra(extra: Record<string, unknown>): DiscussionE
 	if (typeof roundCount !== "number" || !Number.isInteger(roundCount) || roundCount < 0) {
 		throw new Error("invalid Discussion roundCount");
 	}
+	const pendingOptions = record["pendingOptions"];
+	if (pendingOptions !== undefined && (!Array.isArray(pendingOptions) || pendingOptions.some((entry) => typeof entry !== "string"))) {
+		throw new Error("invalid Discussion pendingOptions");
+	}
+	const pendingOptionsMode = record["pendingOptionsMode"];
+	if (pendingOptionsMode !== undefined && !(DISCUSSION_OPTIONS_MODES as readonly unknown[]).includes(pendingOptionsMode)) {
+		throw new Error("invalid Discussion pendingOptionsMode");
+	}
 	return {
 		state: state as DiscussionState,
 		roundCount,
 		...(typeof record["deferredReason"] === "string" ? { deferredReason: record["deferredReason"] } : {}),
 		...(typeof record["settlement"] === "string" ? { settlement: record["settlement"] } : {}),
 		...(typeof record["settledAt"] === "string" ? { settledAt: record["settledAt"] } : {}),
+		...(pendingOptions !== undefined ? { pendingOptions: pendingOptions as string[] } : {}),
+		...(pendingOptionsMode !== undefined ? { pendingOptionsMode: pendingOptionsMode as DiscussionOptionsMode } : {}),
 	};
 }

package/src/modules/discuss.ts

@@ -49,6 +49,13 @@ function taskId(input: OperationInput): string {
 	return value;
 }
 
+function optionsMode(input: OperationInput): "single" | "multi" | undefined {
+	const value = optionalString(input, "options_mode") ?? optionalString(input, "optionsMode");
+	if (value === undefined) return undefined;
+	if (value !== "single" && value !== "multi") throw new Error('options_mode must be "single" or "multi"');
+	return value;
+}
+
 /** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
 export const DISCUSS_OPERATION_NAMES = [
 	"discuss.open", "discuss.reply", "discuss.defer", "discuss.resume", "discuss.settle",
@@ -68,8 +75,16 @@ export function discussOperations(discussions: Discussions): OperationDefinition
 			body: optionalString(input, "body"),
 			labels: optionalStringArray(input, "labels"),
 			blocksTaskIds: optionalStringArray(input, "blocks_task_ids") ?? optionalStringArray(input, "blocksTaskIds"),
+			options: optionalStringArray(input, "options"),
+			optionsMode: optionsMode(input),
+		}, eventContext(input))),
+		define("discuss.reply", (input: OperationInput) => discussions.reply(string(input, "id"), {
+			actor: string(input, "actor"),
+			content: string(input, "content"),
+			selected: optionalStringArray(input, "selected"),
+			options: optionalStringArray(input, "options"),
+			optionsMode: optionsMode(input),
 		}, eventContext(input))),
-		define("discuss.reply", (input: OperationInput) => discussions.reply(string(input, "id"), string(input, "actor"), string(input, "content"), eventContext(input))),
 		define("discuss.defer", (input: OperationInput) => discussions.defer(string(input, "id"), optionalString(input, "reason"), eventContext(input))),
 		define("discuss.resume", (input: OperationInput) => discussions.resume(string(input, "id"), eventContext(input))),
 		define("discuss.settle", (input: OperationInput) => discussions.settle(string(input, "id"), string(input, "settlement"), eventContext(input))),