@a-t-h-i/bot-lobby 0.6.14 → 0.6.16

package/src/ask/types.ts

@@ -6,6 +6,8 @@
  * diagram) shown beside the options.
  */
 
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 /** The questionnaire tool's name, in this session and in the agents that may ask. */
 export const ASK_TOOL = "ask_user_question";
 
@@ -53,3 +55,17 @@ export interface AskResult {
   cancelled: boolean;
   globalNote?: string;
 }
+
+/**
+ * Puts up to `MAX_QUESTIONS` questions to the user and returns what they
+ * chose. `from` names who asks when it is not this session's model (an agent
+ * whose questions the oracle relays).
+ */
+export type Asker = (questions: readonly AskQuestion[], ctx: ExtensionContext, signal?: AbortSignal, from?: string) => Promise<AskResult>;
+
+const IMAGE_EXTENSIONS = /\.(png|jpe?g|gif|webp)$/i;
+
+/** Whether a path names an image the page can show. */
+export function isImagePath(path: string): boolean {
+  return IMAGE_EXTENSIONS.test(path.trim());
+}

package/src/ask/web.ts

@@ -0,0 +1,63 @@
+/**
+ * Putting questions to the user: every question goes to the web page, through
+ * the prompt hub, and waits there for the answer. Nothing is drawn in the
+ * terminal. A question nobody can answer (no page is served, as in a print
+ * run) is put away at once, so a model never waits on a screen that is not
+ * there.
+ */
+import { isAbsolute, resolve } from "node:path";
+import { currentWebServer } from "../webui/server.ts";
+import { promptHub } from "../lobby/prompt-hub.ts";
+import type { AskAnswer, AskQuestion, AskResult, Asker } from "./types.ts";
+
+let availability: (() => boolean) | undefined;
+
+/** Whether the page is up to answer. */
+export function canAsk(): boolean {
+  return availability ? availability() : currentWebServer() !== undefined;
+}
+
+/** Tests say whether a page is there to answer. */
+export function setCanAsk(next: (() => boolean) | undefined): void {
+  availability = next;
+}
+
+/** Image paths made absolute, so the page's preview route finds them whatever the cwd. */
+function withAbsoluteImages(questions: readonly AskQuestion[], cwd: string): AskQuestion[] {
+  return questions.map((question) => ({
+    ...question,
+    options: question.options.map((option) => (option.image?.trim() && !isAbsolute(option.image.trim()) ? { ...option, image: resolve(cwd, option.image.trim()) } : option)),
+  }));
+}
+
+/** What the page sent back, kept to the shape of a result; anything else reads as put away. */
+function readResult(value: unknown): AskResult | undefined {
+  const raw = value as Partial<AskResult> | null;
+  if (!raw || !Array.isArray(raw.answers)) return undefined;
+  return {
+    answers: raw.answers.filter((answer): answer is AskAnswer => typeof answer === "object" && answer !== null && typeof (answer as AskAnswer).questionIndex === "number"),
+    cancelled: raw.cancelled === true,
+    ...(typeof raw.globalNote === "string" ? { globalNote: raw.globalNote } : {}),
+  };
+}
+
+/** The questionnaire in the page. */
+export const askUser: Asker = async (questions, ctx, signal, from) => {
+  if (questions.length === 0 || !canAsk()) return { answers: [], cancelled: true };
+  const outcome = await promptHub.ask("questionnaire", from ?? "oracle", { questions: withAbsoluteImages(questions, ctx.cwd) }, signal ? { signal } : undefined);
+  return (outcome.how === "answered" ? readResult(outcome.value) : undefined) ?? { answers: [], cancelled: true };
+};
+
+/** A free-text answer (possibly several lines) in the page; undefined when put away. */
+export async function askText(question: string, from = "orchestrate"): Promise<string | undefined> {
+  if (!canAsk()) return undefined;
+  const outcome = await promptHub.ask("text", from, { question });
+  return outcome.how === "answered" && typeof outcome.value === "string" ? outcome.value : undefined;
+}
+
+/** One of `options` picked in the page; undefined when put away. */
+export async function askChoice(title: string, options: string[], from = "orchestrate"): Promise<string | undefined> {
+  if (!canAsk()) return undefined;
+  const outcome = await promptHub.ask("choose", from, { title, options });
+  return outcome.how === "answered" && typeof outcome.value === "string" ? outcome.value : undefined;
+}

package/src/classifier/triage.ts

@@ -208,13 +208,14 @@ export function triageLine(triage: TaskTriage): string {
 
 /**
  * A clarify question the classifier can answer: its pick must be the
- * recommended option (marked `(Recommended)`, else the first), confident and
- * clearly ahead; otherwise the question goes to the user as before.
+ * recommended option (marked `(Recommended)`; an unmarked question always goes
+ * to the user), confident and clearly ahead.
  */
 export async function answerClarify(classifier: Classifier, question: string, options: readonly string[], context: { request: string; notes: string; proposal?: string }, signal?: AbortSignal): Promise<AutoAnswer | undefined> {
   if (options.length < 2 || !classifier.enabled("answers")) return undefined;
   const labels = options.map((option) => option.replace(/\s*\(recommended\)\s*/i, " ").trim());
   const marked = options.findIndex((option) => /\(recommended\)/i.test(option));
-  const decided = await autoAnswer(classifier, [{ index: 0, from: "MASTER", text: question, options: labels.map((label) => ({ label, description: "" })), recommended: labels[marked >= 0 ? marked : 0]! }], { request: context.request, conversation: context.notes, ...(context.proposal ? { draft: context.proposal } : {}) }, signal);
+  if (marked < 0) return undefined;
+  const decided = await autoAnswer(classifier, [{ index: 0, from: "MASTER", text: question, options: labels.map((label) => ({ label, description: "" })), recommended: labels[marked]! }], { request: context.request, conversation: context.notes, ...(context.proposal ? { draft: context.proposal } : {}) }, signal);
   return decided?.[0];
 }

package/src/index.ts

@@ -4,6 +4,8 @@ import { registerLifecycle } from "./pi/events.ts";
 import { registerOrchestrateTool } from "./pi/tools.ts";
 import { registerRouteTool } from "./pi/route.ts";
 import { onTransition } from "./state/task-state.ts";
+import { releaseAttachments } from "./state/attachments.ts";
+import { TERMINAL_STATES } from "./schemas/task.ts";
 import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
 import { registerDeskClient } from "./desk/client-extension.ts";
@@ -25,7 +27,11 @@ export default function (pi: ExtensionAPI): void {
   // After the lifecycle, so the lobby opens over a task the status already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
   registerOwner(pi, CONFIG_DIR_NAME);
-  onTransition((task) => pingTransition(task));
+  // A finished task takes the files attached during it along.
+  onTransition((task) => {
+    pingTransition(task);
+    if (TERMINAL_STATES.includes(task.state)) releaseAttachments(task.id);
+  });
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
   // A new request one agent can do alone: the oracle confirms, and the lobby hands it to the quick-fix agent.

package/src/lobby/ask.ts

@@ -1,17 +1,16 @@
 /**
  * The oracle puts the planning panel's questions to the user through the
- * questionnaire (`../ask`): a tab per question with each seat's options, the
- * recommended one first, and a row for an answer in the user's own words.
+ * questionnaire (`../ask`): a card per question with each seat's options (the
+ * recommended one first when the answer is obvious), and a field for an answer in the user's own words.
  * The panel's questions become questionnaires of at most four, and the
  * answers become the user's turn for the next round.
  */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PanelQuestion, SettledQuestion } from "./planner.ts";
-import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult } from "../ask/types.ts";
-import type { Asker } from "../ask/dialog.ts";
+import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type Asker } from "../ask/types.ts";
 
 export { MAX_QUESTIONS, MIN_OPTIONS, MAX_OPTIONS, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type Asker };
-export { askUser, dialogAsker } from "../ask/dialog.ts";
+export { askUser } from "../ask/web.ts";
 
 function clip(text: string, max: number): string {
   const flat = text.replace(/\s+/g, " ").trim();

package/src/lobby/blocks.ts

@@ -0,0 +1,57 @@
+/**
+ * Plain Markdown helpers the lobby shares: model text with escaped line
+ * breaks made real, and a reply split into blocks that can be rendered one by
+ * one (the page renders them, not the terminal).
+ */
+
+/**
+ * Line breaks a model wrote out as `\n` (text escaped twice on its way here,
+ * so a whole plan arrives as one line): made real when the text has no real
+ * line break at all, outside inline code, where `\n` is usually meant.
+ */
+export function unescapeBreaks(text: string): string {
+  if (text.includes("\n") || !text.includes("\\n")) return text;
+  return text
+    .split(/(`[^`\n]*`)/)
+    .map((part, index) => (index % 2 === 1 ? part : part.replace(/(?:\\r)?\\n/g, "\n")))
+    .join("");
+}
+
+/** A fenced code block's opening or closing line. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+/** A list item's first line: after a blank line it continues the list above, so blocks never split there. */
+const LIST_ITEM = /^(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+
+/**
+ * Markdown split into blocks that render, one by one, into the same output as
+ * the whole (each block's lines, a blank line between blocks, blocks that
+ * render to nothing left out). A split falls on a blank line outside code
+ * fences that is followed by an unindented line that does not start a list
+ * item — the only places where one block can never run into the next. A
+ * streaming reply can then keep its finished blocks rendered and render only
+ * the one still being written.
+ */
+export function markdownBlocks(text: string): string[] {
+  const lines = text.split("\n");
+  const blocks: string[] = [];
+  let fence: string | undefined;
+  let start = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]!;
+    const marker = FENCE.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = undefined;
+      continue;
+    }
+    if (fence || line.trim() || index === 0) continue;
+    const next = lines[index + 1];
+    if (next === undefined || !/^\S/.test(next) || LIST_ITEM.test(next)) continue;
+    const block = lines.slice(start, index).join("\n");
+    if (block.trim()) blocks.push(block);
+    start = index + 1;
+  }
+  const last = lines.slice(start).join("\n");
+  if (last.trim()) blocks.push(last);
+  return blocks;
+}

package/src/lobby/feed.ts

@@ -7,7 +7,7 @@
  */
 import type { AgentRun } from "../schemas/findings.ts";
 import { agentName } from "../pi/run-summary.ts";
-import { markdownBlocks } from "./markdown.ts";
+import { markdownBlocks } from "./blocks.ts";
 
 export type ActivityKind = "info" | "success" | "warning" | "error";
 

package/src/lobby/host.ts

@@ -0,0 +1,178 @@
+/**
+ * What the lobby's backend offers: the service interface the web server
+ * drives, and the shapes of the sessions it lists. Pure types (the
+ * implementation is `service.ts`).
+ */
+import type { Task } from "../schemas/task.ts";
+import type { AgentRun } from "../schemas/findings.ts";
+import type { PlannedTask } from "../state/backlog.ts";
+import type { PlanComment } from "../state/comments.ts";
+import type { MetricRecord } from "../state/metrics.ts";
+import type { BotLobbyConfig, LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
+import type { ChatEntry, LobbyFeed } from "./feed.ts";
+import type { BackgroundSession } from "./sessions.ts";
+import type { QuickFixQueue } from "./quickfix.ts";
+import type { PlannerSeed, PlanningSession } from "./planner.ts";
+import type { IssuesState } from "./issues.ts";
+import type { PullsState } from "./pulls.ts";
+import type { PullReviews } from "./pr-review.ts";
+import type { KnowledgeBook } from "./knowledge.ts";
+import type { ExcalidrawBook, ExcalidrawSession } from "../excalidraw/sessions.ts";
+import type { WorkspaceInfo } from "../execution/workspace.ts";
+
+export { TAB_IDS, TAB_LABELS, visibleTabs } from "./prompts.ts";
+export type { TabId } from "./prompts.ts";
+
+/** What a checked Excalidraw session reported. */
+export interface SessionCheck {
+  ok: boolean;
+  text: string;
+}
+
+/**
+ * Which session the Lobby tab shows and talks to: this window, one it started
+ * in the background, one running in another terminal, or a task whose
+ * session is not running at all.
+ */
+export type SessionView =
+  | { kind: "here" }
+  | { kind: "background"; key: string }
+  | { kind: "other"; sessionId: string }
+  | { kind: "idle"; taskId: string };
+
+export type SessionWhere = "this window" | "background" | "other terminal" | "not running";
+
+/** One row of the session browser. */
+export interface SessionEntry {
+  view: SessionView;
+  name: string;
+  where: SessionWhere;
+  task?: Task;
+  /** What it is doing: working, idle, starting, ended, or its task's state. */
+  status: string;
+  auto: boolean;
+  /** Questions it waits on you for. */
+  waiting: number;
+  /** The pi session it is (absent for a task no session ever owned). */
+  sessionId?: string;
+  /** The process running it, for sessions in other terminals. */
+  pid?: number;
+}
+
+/** A session running in this project, as its heartbeat tells (see state/presence.ts). */
+export interface LiveSession {
+  sessionId: string;
+  pid: number;
+  name?: string;
+  taskId?: string;
+  mode: string;
+}
+
+/** What `switchTo` needs: the session to run in this window, and the background process to stop first. */
+export interface SwitchTarget {
+  name: string;
+  sessionId?: string;
+  background?: BackgroundSession;
+  /** A task no session owns: this window claims it instead. */
+  claimTaskId?: string;
+}
+
+/** One model Pi offers, for the settings page's picker: `provider/id`, its label and thinking levels. */
+export interface ModelChoice {
+  id: string;
+  label: string;
+  thinkingLevels: string[];
+}
+
+/** Everything the web server needs from pi and bot-lobby. */
+export interface LobbyService {
+  sessionId(): string | undefined;
+  /** This session's active task and its runs, as the lobby reads them. */
+  zen(): { task?: Task; runs: readonly AgentRun[] };
+  feed: LobbyFeed;
+  masterBusy(): boolean;
+  tasks(): Task[];
+  plans(): PlannedTask[];
+  comments(taskId: string): PlanComment[];
+  metrics(): MetricRecord[];
+  /** Classifier calls (kind `classifier`), kept out of the agent tables. */
+  classifierMetrics?(): MetricRecord[];
+  /** Send text to the oracle, or start a task when none is active; returns a notice. */
+  toOracle(text: string): string | undefined;
+  comment(taskId: string, text: string): string;
+  startPlanned(plan: PlannedTask): string;
+  discardPlan(id: string): void;
+  abortMaster(): void;
+  quickfix: QuickFixQueue;
+  planner(): PlanningSession | undefined;
+  /** Start a planning session (replacing any other) with these seats on the panel. */
+  newPlanner(seed?: PlannerSeed, seats?: readonly PanelMember[]): PlanningSession;
+  /** The oracle puts the panel's open questions to the user, one questionnaire at a time; returns a notice. */
+  answerPanel(): Promise<string>;
+  /** Save the plan as a pending task, offering to split a long one into several first; returns a notice. */
+  savePlan(): Promise<string>;
+  /** The seats a new session starts with, from settings. */
+  defaultPanel(): readonly PanelMember[];
+  /** Planning rounds before the oracle finalizes alone (`lobby.maxPlanningRounds`); 0 = unlimited. */
+  planningRounds?(): number;
+  /** `model · thinking` a panel seat runs on. */
+  seatLabel(member: PanelMember): string;
+  issues: IssuesState;
+  /** The Git tab's pull requests, read through `gh`. */
+  pulls: PullsState;
+  /** Reviews of pull requests by an agent, and Jev's reads of them. */
+  reviews: PullReviews;
+  /** Every agent's knowledge files: read, edited, commented on. */
+  knowledge: KnowledgeBook;
+  /** The shared Excalidraw sessions (five at most) and which agents each is assigned to. */
+  excalidraw: ExcalidrawBook;
+  /** Join a session's room for a moment and report what is there. */
+  checkExcalidraw(session: ExcalidrawSession): Promise<SessionCheck>;
+  /** The effective config, never a secret; the web settings page reads it. */
+  config?(): BotLobbyConfig;
+  /** Save a whole config, the way the settings menu does; the web settings page writes it. */
+  saveConfig?(config: BotLobbyConfig): void;
+  /** Reload cached config (keys, panes) after a settings change. */
+  configChanged?(): void;
+  /** The models Pi offers, for the settings page's picker. */
+  models?(): ModelChoice[];
+  /** The model this window's session runs on (`provider/id`), when it has one. */
+  sessionModel?(): string | undefined;
+  /** The Issues tab is switched on (`lobby.issues`). */
+  issuesEnabled(): boolean;
+  /** This window's pi session name, when it has one. */
+  sessionName(): string | undefined;
+  /** Background sessions this window started, oldest first. */
+  sessions(): readonly BackgroundSession[];
+  /** Start a task in a new background session, named after the task; the session, or why not. */
+  startSession(start: { request?: string; plan?: PlannedTask; auto?: boolean }): BackgroundSession | string;
+  /** Auto mode for any task, whichever session drives it. */
+  isAuto(taskId: string): boolean;
+  setAuto(taskId: string, on: boolean): void;
+  /** Leave a message for a task's oracle, delivered by whichever session drives it (now or once one resumes it); returns a notice. */
+  sendToTask(taskId: string, text: string): string;
+  /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
+  sendToSession(sessionId: string, text: string): string;
+  /** Sessions running in this project, other than this window's, from their heartbeats. */
+  liveSessions(): readonly LiveSession[];
+  /** Run another session in this window (stopping its background process first); resolves to a notice. */
+  switchTo(target: SwitchTarget): Promise<string>;
+  /** Archived tasks, most recently archived first. */
+  archivedTasks(): Task[];
+  /** Archive, restore or delete a task; each returns a notice. */
+  archiveTask(taskId: string): string;
+  restoreTask(taskId: string): string;
+  deleteTask(taskId: string, where: "list" | "archive"): string;
+  /** Another session's conversation, read from its saved session file (its newest messages). */
+  sessionChat(sessionId: string): ChatEntry[];
+  /** Whether another session has messages earlier than `sessionChat` returns. */
+  hasOlderChat(sessionId: string): boolean;
+  /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
+  chatHistory(sessionId?: string): readonly ChatEntry[];
+  profileLabel(kind: LobbyAgentKind): string;
+  /** The repository (or folder) and branch the title shows; the folder's name alone until git has answered. */
+  workspace?(): WorkspaceInfo;
+  /** Ask for the workspace to be read again (the branch may have changed); it arrives through `workspace()`. */
+  refreshWorkspace?(): void;
+}
+

package/src/lobby/keys.ts

@@ -1,27 +1,17 @@
 /**
- * The lobby's shortcuts in one table: every action has a default key, a line
- * for the help overlay, and can be rebound under `lobby.keys` in the config
- * (`{ "toggleThinking": "alt+t" }`). They work in typing and browsing mode
- * alike, so each default is a key that never types a character.
+ * The web lobby's shortcuts in one table: every action has a default key, a
+ * line for the help overlay, and can be rebound under `lobby.keys` in the
+ * config (`{ "search": "alt+f" }`). Chords are written `alt+k`,
+ * `ctrl+f`, `shift+tab`; the page matches them on the physical key.
  */
-import { Key, matchesKey, type KeyId } from "@earendil-works/pi-tui";
 
 export const LOBBY_ACTIONS = {
-  hide: { key: "alt+l", help: "hide the lobby (back to pi)" },
-  help: { key: "alt+h", help: "show or hide these keys" },
-  settings: { key: "alt+s", help: "bot-lobby settings: each agent's model and thinking, the lobby" },
-  search: { key: "ctrl+f", help: "search the current tab" },
-  savePlan: { key: "ctrl+s", help: "save the plan being made in the Plan tab to the pending tasks" },
-  sessions: { key: "alt+o", help: "browse sessions: view one, message it, or switch this window to it" },
-  newSession: { key: "alt+n", help: "start a task in a new session, named after it" },
-  toggleAuto: { key: "alt+g", help: "auto mode: the oracle drives the task to completion without asking" },
-  nextTab: { key: "tab", help: "next tab" },
-  prevTab: { key: "shift+tab", help: "previous tab" },
-  toggleConversation: { key: "alt+c", help: "show or hide the conversation" },
-  toggleActivity: { key: "alt+a", help: "show or hide the activity log" },
-  toggleThinking: { key: "alt+k", help: "show or hide thinking" },
-  scrollUp: { key: "pageUp", help: "scroll up a page" },
-  scrollDown: { key: "pageDown", help: "scroll down a page" },
+  help: { key: "alt+h", help: "show or hide this list" },
+  settings: { key: "alt+s", help: "settings: each agent's model and effort" },
+  savePlan: { key: "ctrl+s", help: "save the plan from the Plan tab" },
+  sessions: { key: "alt+o", help: "browse and message your sessions" },
+  nextTab: { key: "alt+]", help: "next tab" },
+  prevTab: { key: "alt+[", help: "previous tab" },
 } as const;
 
 export type LobbyAction = keyof typeof LOBBY_ACTIONS;
@@ -37,27 +27,6 @@ export function keyMap(overrides: Readonly<Record<string, string>> = {}): KeyMap
   return map;
 }
 
-/** Alt+digit jumps to the tab at `index`; the same key the TUI matches. */
-export function tabJumpKey(index: number): KeyId {
-  return Key.alt(String(index + 1) as "1");
-}
-
-/** `keyMap` with the web-only tab cycling defaults; user overrides win. */
-export function webKeyMap(overrides: Readonly<Record<string, string>> = {}): KeyMap {
-  const map = keyMap(overrides);
-  if (!overrides.nextTab?.trim()) map.nextTab = "alt+]";
-  if (!overrides.prevTab?.trim()) map.prevTab = "alt+[";
-  return map;
-}
-
-/** The action `data` triggers under `map`, if any. */
-export function actionFor(data: string, map: KeyMap): LobbyAction | undefined {
-  for (const action of Object.keys(map) as LobbyAction[]) {
-    if (matchesKey(data, map[action] as KeyId)) return action;
-  }
-  return undefined;
-}
-
 /** `alt+k` reads `Alt+K` in hints and help. */
 export function keyLabel(key: string): string {
   return key

package/src/lobby/planner.ts

@@ -173,10 +173,10 @@ export function roundMode(round: number, limit: number): RoundMode {
 /** What the oracle is told to do at the end of its task, by round mode. */
 export function oracleClosing(mode: RoundMode, round: number, limit: number): string {
   if (mode === "final") {
-    return `Final round (${round} of ${limit}): no seat runs this round and nothing more is asked. Fold the user's answers into the plan, decide every point still open with its recommended option and list each under ### Assumptions, and set Status READY. Omit the Questions section. Reply in the required output format.`;
+    return `Final round (${round} of ${limit}): no seat runs this round and nothing more is asked. Fold the user's answers into the plan, decide every point still open (with its marked option where there is one, otherwise your best call) and list each under ### Assumptions, and set Status READY. Omit the Questions section. Reply in the required output format.`;
   }
   if (mode === "revise") {
-    return `The planning round limit (${limit}) is reached: revise the plan for the user's latest message and comments. Ask nothing; decide anything open with its recommended option under ### Assumptions, and keep Status READY. Omit the Questions section. Reply in the required output format.`;
+    return `The planning round limit (${limit}) is reached: revise the plan for the user's latest message and comments. Ask nothing; decide anything open (with its marked option where there is one, otherwise your best call) under ### Assumptions, and keep Status READY. Omit the Questions section. Reply in the required output format.`;
   }
   const bound = limit > 0 ? `Round ${round} of ${limit}; in round ${limit} you settle whatever is still open alone, so ask the decisive questions now. ` : "";
   return `${bound}Continue: fold the panel's notes and the user's answers into the plan, ask what no seat owns, or declare the plan READY. Reply in the required output format.`;
@@ -225,9 +225,9 @@ export function parseOption(text: string): PanelOption {
   return split ? { label: split[1]!.trim(), description: split[2]!.trim() } : { label: flat, description: "" };
 }
 
-/** The option the asker recommends: the one marked `(Recommended)`, else the first. */
+/** The option the asker recommends: only the one marked `(Recommended)`; nothing is implied by order. */
 export function recommendedOption(question: AskedQuestion): PanelOption | undefined {
-  return question.options.find((option) => /\(recommended\)/i.test(option.label)) ?? question.options[0];
+  return question.options.find((option) => /\(recommended\)/i.test(option.label));
 }
 
 /** An option's label without its `(Recommended)` marker. */