@a-t-h-i/bot-lobby 0.6.1 → 0.6.2

package/src/execution/agent-runner.ts

@@ -55,6 +55,9 @@ export interface AgentRequest {
   onStart?: (handle: AgentHandle) => void;
   /** Called once per attempt after it ends, before any retry. */
   onAttemptEnd?: (run: AgentRun) => void;
+  /** The classifier routed this run down from this configured profile (receipts and metrics show it). */
+  routedFrom?: string;
+  route?: string;
 }
 
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
@@ -115,6 +118,8 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     attempts,
     startedAt,
     ...(request.thinking ? { thinking: request.thinking } : {}),
+    ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
+    ...(request.route ? { route: request.route } : {}),
     ...(attempts > 1 ? { note: `retry ${attempts - 1} of ${(request.retries ?? 0)}`, noteKind: "warning" as const } : {}),
   };
 }

package/src/index.ts

@@ -8,8 +8,12 @@ import { isSubagentProcess } from "./pi/quiet.ts";
 import { registerDeskClient } from "./desk/client-extension.ts";
 import { registerLobbyEvents } from "./lobby/runtime.ts";
 import { registerOwner } from "./pi/owner.ts";
+import { registerClassifier } from "./classifier/instance.ts";
+import { registerClassifierTools } from "./classifier/tools.ts";
 
 export default function (pi: ExtensionAPI): void {
+  // First, so every session_start handler below finds the classifier bound to this session's keys.
+  registerClassifier(pi, CONFIG_DIR_NAME);
   registerLifecycle(pi, CONFIG_DIR_NAME);
   // After the lifecycle, so the lobby opens over a task the widget state already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
@@ -19,4 +23,6 @@ export default function (pi: ExtensionAPI): void {
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
   // Parallel workers share files through the master's file desk.
   if (isSubagentProcess()) registerDeskClient(pi);
+  // Subagents look files up with the classifier (the engine allows the tool only while file hints are on).
+  if (isSubagentProcess()) registerClassifierTools(pi);
 }

package/src/lobby/planner.ts

@@ -10,6 +10,12 @@
  * Each round runs the seats in parallel (read-only; RESEARCH may also use the
  * web tools), then the oracle over their output. Rounds replay the whole
  * conversation, so one can be stopped or retried without losing the session.
+ * A round limit bounds the grilling: the last round skips the seats and the
+ * oracle decides whatever is still open, and later replies only revise.
+ * With the classifier on, each round seats only the members whose domain the
+ * idea or the latest answers touch (a key press pins a seat on or off), and
+ * questions whose recommended option the conversation already makes clearly
+ * right are answered without asking.
  * The agreed plan is saved as a pending task.
  */
 import { loadPrompt } from "../prompts/loader.ts";
@@ -23,6 +29,11 @@ import { truncate } from "../text.ts";
 import type { LobbyFeed } from "./feed.ts";
 import type { QuickFixProfile } from "./quickfix.ts";
 import { MAX_QUESTIONS, type AskResult } from "./ask.ts";
+import type { Classifier } from "../classifier/classifier.ts";
+import { chooseSeats } from "../classifier/seats.ts";
+import { autoAnswer, type AutoAnswer } from "../classifier/answers.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import { fellShort, profileLabel, type EffortRouter, type EffortScore } from "../classifier/effort.ts";
 
 /** Seats and the oracle read the repository to ask informed questions; they never edit. */
 export const PLANNER_TOOLS: readonly string[] = ["read", "grep", "find", "ls"];
@@ -65,6 +76,8 @@ export interface PlannerMessage {
   at: number;
   /** The round's questions, attributed, when the panel asked any. */
   questions?: PanelQuestion[];
+  /** Questions the classifier answered with their recommended option instead of asking. */
+  decided?: AutoAnswer[];
 }
 
 /** The oracle's reply: its verdict, title, own questions and the draft plan. */
@@ -118,6 +131,46 @@ export interface PlannerDeps {
   onChange?: () => void;
   /** Called when a round ends (answered, failed or stopped), so the lobby can put the questions to the user. */
   onRound?: (session: PlanningSession) => void;
+  /** Rounds before the oracle finalizes alone (0 or absent = unlimited); read as each round starts. */
+  maxRounds?: () => number;
+  /** Chooses the round's seats and answers obvious questions when it is on; absent, every seat sits and you answer everything. */
+  classifier?: Classifier;
+  /** Likely files for the round (idea and latest answers), and the lookup tool, while file hints are on. */
+  hints?: FileHinter;
+  /** Lowers a seat's thinking (or model) when the classifier judges the idea simple or trivial; the oracle is never routed. */
+  effort?: EffortRouter;
+}
+
+/** What the user's turn says when the classifier settled every question of a round. */
+export const CLASSIFIER_CONTINUE = "(No answers needed from me this round: the classifier settled the questions above. Continue.)";
+
+/**
+ * How a round runs under the limit: `normal` grilling with the seats, the
+ * `final` round (the oracle alone, deciding what is open), or `revise` once
+ * past the limit (the oracle alone, revising for the user's latest message).
+ */
+export type RoundMode = "normal" | "final" | "revise";
+
+export function roundMode(round: number, limit: number): RoundMode {
+  if (limit <= 0 || round < limit) return "normal";
+  return round === limit ? "final" : "revise";
+}
+
+/** 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.`;
+  }
+  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.`;
+  }
+  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.`;
+}
+
+/** `round 2 of 5`, for a seat's task; empty without a limit. */
+function roundNote(round: number, limit: number): string {
+  return limit > 0 ? ` (round ${round} of ${limit})` : "";
 }
 
 /** Split a reply into its top-level `## Section` bodies, keyed by lower-case title. */
@@ -158,6 +211,36 @@ 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. */
+export function recommendedOption(question: AskedQuestion): PanelOption | undefined {
+  return question.options.find((option) => /\(recommended\)/i.test(option.label)) ?? question.options[0];
+}
+
+/** An option's label without its `(Recommended)` marker. */
+export function optionLabel(option: PanelOption): string {
+  return option.label.replace(/\s*\(recommended\)\s*/i, " ").trim();
+}
+
+/**
+ * Record questions nobody will ask any more as assumptions in the plan, each
+ * decided with its recommended option: under the plan's `### Assumptions`
+ * section when it has one, otherwise in a new one at the end.
+ */
+export function appendAssumptions(plan: string, questions: readonly PanelQuestion[], why: string): string {
+  if (questions.length === 0) return plan;
+  const lines = questions.map((question) => {
+    const pick = recommendedOption(question);
+    return `- [${question.from}] ${question.text} → ${pick ? optionLabel(pick) : "the oracle's call"} (${why})`;
+  });
+  const rows = plan.split("\n");
+  const heading = rows.findIndex((row) => /^#{2,3}\s+assumptions\s*$/i.test(row.trim()));
+  if (heading < 0) return `${plan.trimEnd()}\n\n### Assumptions\n${lines.join("\n")}`;
+  let end = rows.findIndex((row, index) => index > heading && /^#{1,3}\s/.test(row));
+  if (end < 0) end = rows.length;
+  while (end > heading + 1 && rows[end - 1]!.trim() === "") end -= 1;
+  return [...rows.slice(0, end), ...lines, ...rows.slice(end)].join("\n");
+}
+
 /** Inline `a) … b) …` choices, when a question carries its options in its own text. */
 function inlineOptions(question: AskedQuestion): AskedQuestion {
   if (question.options.length > 0) return question;
@@ -251,6 +334,7 @@ export function plannerTranscript(messages: readonly PlannerMessage[], seed?: Pl
   for (const message of messages) {
     const body = message.questions && message.questions.length > 0 ? message.questions.map(questionLine).join("\n") : message.text.trim();
     lines.push(message.role === "you" ? "### User" : "### Panel", "", body, "");
+    if (message.decided && message.decided.length > 0) lines.push(decidedBlock(message.decided), "");
   }
   if (draft) lines.push("## The oracle's current draft plan", "", truncate(draft, 8000), "");
   lines.push(closing);
@@ -263,6 +347,14 @@ export interface MemberOutcome {
   error?: string;
 }
 
+/** Questions the classifier answered, as every seat and the oracle read them. */
+export function decidedBlock(decided: readonly AutoAnswer[]): string {
+  return [
+    "Decided by the classifier (each is the recommended option, which the conversation already makes clearly right; list them under Assumptions, the user can overrule them):",
+    ...decided.map((entry) => `- [${entry.from}] ${entry.question} → ${entry.answer} (${entry.probability.toFixed(2)})`),
+  ].join("\n");
+}
+
 /** The seats' output for the oracle: each seat's status, questions and notes, or its failure. */
 export function panelSection(outcomes: readonly MemberOutcome[]): string {
   if (outcomes.length === 0) return "## Panel this round\n\nNo domain seats this round; you are planning alone.";
@@ -293,7 +385,12 @@ export function commentBlock(comments: readonly LineComment[]): string {
 }
 
 /** What the panel said in a round, as the conversation shows it. */
-export function plannerSays(ready: boolean, questions: readonly PanelQuestion[]): string {
+export function plannerSays(ready: boolean, questions: readonly PanelQuestion[], mode: RoundMode = "normal"): string {
+  if (mode !== "normal") {
+    return ready
+      ? "The round limit is reached: the oracle decided what was still open (see Assumptions). Save the plan, or comment on a line to revise it."
+      : "The round limit is reached, but there is no draft yet. Reply or retry to let the oracle write one.";
+  }
   if (ready) return "The panel agrees the plan is clear. Save it as a pending task, or keep refining.";
   if (questions.length === 0) return "No open questions this round. Save the draft, or add detail.";
   return questions.map(questionLine).join("\n");
@@ -343,7 +440,19 @@ export class PlanningSession {
   answered: AskResult[] = [];
   /** Comments on draft lines, sent with the user's next turn. */
   lineComments: LineComment[] = [];
+  /** How the latest round ran under the round limit. */
+  mode: RoundMode = "normal";
+  /** Seats pinned on with a key press: they sit every round, whatever the classifier says. */
+  readonly pins = new Set<PanelMember>();
+  /** Seats the classifier left out of the latest round, with how likely it judged them needed. */
+  satOut = new Map<PanelMember, number>();
+  /** How each seat left the last round it sat. */
+  private readonly lastStatus = new Map<PanelMember, "ready" | "open">();
+  /** The last round was started by the classifier settling every question; the next one waits for the user. */
+  private autoContinued = false;
   private controller?: AbortController;
+  /** Round attempts, retries included, so each attempt's feed steps stay apart. */
+  private attempts = 0;
   private readonly deps: PlannerDeps;
   private readonly memberNotes = new Map<PanelMember, string[]>();
 
@@ -361,16 +470,40 @@ export class PlanningSession {
     return this.status === "thinking";
   }
 
-  /** Seat or unseat a member for the next round; returns whether it now sits. */
+  /** Rounds before the oracle finalizes alone; 0 = unlimited. */
+  get limit(): number {
+    return Math.max(0, this.deps.maxRounds?.() ?? 0);
+  }
+
+  /** How the next round will run. */
+  get nextMode(): RoundMode {
+    return roundMode(this.turns + 1, this.limit);
+  }
+
+  /**
+   * Seat or unseat a member for the next round; returns whether it now sits.
+   * Seating one pins it (it sits every round, whatever the classifier says);
+   * unseating keeps it off until seated again.
+   */
   toggle(member: PanelMember): boolean {
-    if (this.seats.has(member)) this.seats.delete(member);
-    else this.seats.add(member);
+    if (this.seats.has(member)) {
+      this.seats.delete(member);
+      this.pins.delete(member);
+    } else {
+      this.seats.add(member);
+      this.pins.add(member);
+    }
     this.deps.onChange?.();
     return this.seats.has(member);
   }
 
   /** Add the user's message (the idea, or answers), with any line comments, and run a round. */
   async send(text: string): Promise<void> {
+    this.autoContinued = false;
+    await this.post(text);
+  }
+
+  private async post(text: string): Promise<void> {
     const body = [text.trim(), commentBlock(this.lineComments)].filter(Boolean).join("\n\n");
     if (!body) return;
     if (this.busy) throw new Error("the panel is still thinking");
@@ -417,6 +550,8 @@ export class PlanningSession {
   async retry(): Promise<void> {
     if (!this.retryable) return;
     if (this.messages.at(-1)?.role === "planner") this.messages = this.messages.slice(0, -1);
+    // A retry replays the same round; it does not use up another one.
+    this.turns = Math.max(0, this.turns - 1);
     await this.turn();
   }
 
@@ -439,7 +574,7 @@ export class PlanningSession {
   }
 
   private stepKey(who: string): string {
-    return `plan-${who}-${this.turns}`;
+    return `plan-${who}-${this.attempts}`;
   }
 
   /** Stream one agent's steps and thoughts into its state and the lobby feed. */
@@ -454,7 +589,7 @@ export class PlanningSession {
     this.deps.onChange?.();
   }
 
-  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void): Promise<RunOutcome> {
+  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
     const startedAt = Date.now();
     let outcome: RunOutcome;
     try {
@@ -477,23 +612,55 @@ export class PlanningSession {
       outcome = { status: "failed", output: "", error: (error as Error).message, usage: { input: 0, output: 0, cost: 0, turns: 0 } };
     }
     this.deps.feed?.end(this.stepKey(label), outcome.status !== "success");
-    appendMetrics(this.deps.root, this.deps.configDir, [planningMetric(kind, label, this.turns, startedAt, outcome.status, profile, outcome.model, outcome.usage)]);
+    const metric = planningMetric(kind, label, this.turns, startedAt, outcome.status, profile, outcome.model, outcome.usage);
+    appendMetrics(this.deps.root, this.deps.configDir, [routedFrom ? { ...metric, routedFrom } : metric]);
     return outcome;
   }
 
-  private async runMember(state: MemberState, transcript: string, signal: AbortSignal): Promise<MemberOutcome> {
+  /** The read-only tools a seat (or the oracle) gets, plus the file lookup while hints are on. */
+  private tools(base: readonly string[]): readonly string[] {
+    const extra = this.deps.hints?.tools() ?? [];
+    return extra.length > 0 ? [...base, ...extra] : base;
+  }
+
+  /** The round's Likely files, ranked once against the idea and the latest answers. */
+  private async likely(signal: AbortSignal): Promise<string> {
+    if (!this.deps.hints) return "";
+    try {
+      return await this.deps.hints.block(`${this.idea()}\n\n${this.latest()}`, signal);
+    } catch {
+      return "";
+    }
+  }
+
+  /** How hard the round's idea is, scored once and shared by every seat. */
+  private async scoreRound(signal: AbortSignal): Promise<EffortScore | undefined> {
+    if (!this.deps.effort) return undefined;
+    try {
+      return await this.deps.effort.score(`Plan this with the user, asking only what changes how it is built:\n${this.idea()}\n\n${this.latest()}`, { signal });
+    } catch {
+      return undefined;
+    }
+  }
+
+  private async runMember(state: MemberState, transcript: string, signal: AbortSignal, effort?: EffortScore): Promise<MemberOutcome> {
     const member = state.member;
     const label = MEMBER_LABELS[member];
     const profile = this.deps.memberProfile?.(member) ?? this.deps.profile();
-    const outcome = await this.run(label, "panel", profile, {
-      task: `${transcript}\n\nYou are ${label} on the planning panel: ask your seat's open questions, or declare READY.`,
+    const request = {
+      task: `${transcript}\n\nYou are ${label} on the planning panel${roundNote(this.turns, this.limit)}: ask your seat's open questions, or declare READY.`,
       systemPrompt: memberPrompt(member, profile.instructions),
-      tools: member === "researcher" ? RESEARCH_PANEL_TOOLS : PLANNER_TOOLS,
-    }, signal, (step) => (state.step = step));
+      tools: this.tools(member === "researcher" ? RESEARCH_PANEL_TOOLS : PLANNER_TOOLS),
+    };
+    const route = effort ? this.deps.effort?.plan(effort, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }) : undefined;
+    let outcome = await this.run(label, "panel", route ? { ...profile, model: route.model, thinking: route.thinking } : profile, request, signal, (step) => (state.step = step), route ? profileLabel(route.from) : undefined);
+    // A routed seat that fails asks again on its configured model and thinking.
+    if (route && fellShort(outcome) && !signal.aborted) outcome = await this.run(label, "panel", profile, request, signal, (step) => (state.step = step));
     if (outcome.status === "success") {
       state.reply = parseMemberReply(outcome.output);
       state.status = "done";
       this.memberNotes.set(member, state.reply.notes);
+      this.lastStatus.set(member, state.reply.status === "ready" ? "ready" : "open");
     } else {
       state.status = "failed";
       state.error = outcome.error ?? outcome.status;
@@ -510,25 +677,38 @@ export class PlanningSession {
     this.status = "thinking";
     this.error = undefined;
     this.turns += 1;
+    this.attempts += 1;
     this.answered = [];
-    this.members = PANEL_MEMBERS.filter((member) => this.seats.has(member)).map((member) => ({ member, status: "thinking", step: "reading the conversation" }));
-    this.step = this.members.length > 0 ? "waiting for the panel" : "reading the conversation";
+    const limit = this.limit;
+    const mode = roundMode(this.turns, limit);
+    this.mode = mode;
+    // At and past the limit the oracle works alone: the seats have had their rounds.
+    const eligible = mode === "normal" ? PANEL_MEMBERS.filter((member) => this.seats.has(member)) : [];
+    this.members = [];
+    this.satOut = new Map();
+    this.step = "reading the conversation";
     this.deps.onChange?.();
     try {
-      const transcript = plannerTranscript(this.messages, this.seed, this.reply?.plan, "");
-      const outcomes = await Promise.all(this.members.map((state) => this.runMember(state, transcript, controller.signal)));
+      const [seated, likely, effort] = await Promise.all([this.chooseSeats(eligible, controller.signal), this.likely(controller.signal), eligible.length > 0 ? this.scoreRound(controller.signal) : undefined]);
+      if (controller.signal.aborted) throw new Error("stopped");
+      this.members = seated.map((member) => ({ member, status: "thinking", step: "reading the conversation" }));
+      this.step = this.members.length > 0 ? "waiting for the panel" : "reading the conversation";
+      this.deps.onChange?.();
+      const transcript = [plannerTranscript(this.messages, this.seed, this.reply?.plan, ""), likely].filter(Boolean).join("\n\n");
+      const outcomes = await Promise.all(this.members.map((state) => this.runMember(state, transcript, controller.signal, effort)));
       if (controller.signal.aborted) throw new Error("stopped");
       this.notes = PANEL_MEMBERS.flatMap((member) => (this.memberNotes.get(member) ?? []).map((text) => ({ from: MEMBER_LABELS[member], text })));
       this.step = "writing the plan";
       this.deps.onChange?.();
       const profile = this.deps.profile();
       const lead = await this.run(ORACLE_LABEL, "planner", profile, {
-        task: `${plannerTranscript(this.messages, this.seed, this.reply?.plan, "")}\n\n${panelSection(outcomes)}\n\nContinue: 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.`,
+        task: `${transcript}\n\n${panelSection(outcomes)}\n\n${oracleClosing(mode, this.turns, limit)}`,
         systemPrompt: plannerPrompt(profile.instructions),
-        tools: PLANNER_TOOLS,
+        tools: this.tools(PLANNER_TOOLS),
       }, controller.signal, (step) => (this.step = step));
       if (controller.signal.aborted) throw new Error("stopped");
-      this.finishRound(outcomes, lead);
+      this.finishRound(outcomes, lead, mode);
+      if (mode === "normal" && this.questions.length > 0) await this.answerObvious(controller.signal);
     } catch (error) {
       this.error = (error as Error).message;
     } finally {
@@ -540,26 +720,124 @@ export class PlanningSession {
       this.deps.onRound?.(this);
     }
     // Comments left on draft lines during the round go to the panel now, unless questions wait (they ride with the answers).
-    if (!this.error && !this.busy && this.questions.length === 0 && this.lineComments.length > 0) await this.send("");
+    if (!this.error && !this.busy && this.questions.length === 0 && this.lineComments.length > 0) {
+      await this.send("");
+      return;
+    }
+    // The classifier settled every question: the panel folds those answers in without waiting for you, once in a row.
+    const settled = this.messages.at(-1)?.decided?.length ?? 0;
+    if (!this.error && !this.busy && settled > 0 && this.questions.length === 0 && this.reply?.status !== "ready" && !this.autoContinued) {
+      this.autoContinued = true;
+      await this.post(CLASSIFIER_CONTINUE);
+    }
+  }
+
+  /** The idea as first described, with the source issue. */
+  private idea(): string {
+    const first = this.messages.find((message) => message.role === "you")?.text ?? "";
+    return this.seed ? `Issue #${this.seed.issue.number}: ${this.seed.issue.title}\n\n${this.seed.body}\n\n${first}`.trim() : first;
   }
 
-  /** The oracle's reply sets the round's questions (chosen from the seats' and its own), verdict and draft. */
-  private finishRound(outcomes: readonly MemberOutcome[], lead: RunOutcome): void {
+  /** The user's newest message, with any answers the classifier gave in the round before it. */
+  private latest(): string {
+    let index = this.messages.length - 1;
+    while (index >= 0 && this.messages[index]!.role !== "you") index -= 1;
+    if (index < 0) return "";
+    const decided = this.messages[index - 1]?.decided;
+    return [decided && decided.length > 0 ? decidedBlock(decided) : "", this.messages[index]!.text].filter(Boolean).join("\n\n");
+  }
+
+  /**
+   * The seats that sit this round: every eligible seat, unless the classifier
+   * judges some unpinned ones not needed. Pinned seats always sit; a failure
+   * or a classifier that is off seats everyone.
+   */
+  private async chooseSeats(eligible: readonly PanelMember[], signal: AbortSignal): Promise<PanelMember[]> {
+    const jev = this.deps.classifier;
+    const open = eligible.filter((member) => !this.pins.has(member));
+    if (!jev || open.length === 0 || !jev.enabled("seats")) return [...eligible];
+    this.step = "choosing seats";
+    this.deps.onChange?.();
+    const decision = await chooseSeats(jev, {
+      round: this.turns,
+      idea: this.idea(),
+      latest: this.latest(),
+      ...(this.reply?.plan ? { draft: this.reply.plan } : {}),
+      candidates: open.map((member) => ({
+        member,
+        label: MEMBER_LABELS[member],
+        owns: MEMBER_SEATS[member],
+        ...(this.lastStatus.has(member) ? { lastStatus: this.lastStatus.get(member)! } : {}),
+        notes: this.memberNotes.get(member) ?? [],
+      })),
+    }, signal);
+    if (!decision) return [...eligible];
+    const seated = eligible.filter((member) => this.pins.has(member) || decision.seat.has(member));
+    for (const member of open) if (!decision.seat.has(member)) this.satOut.set(member, decision.probabilities.get(member) ?? 0);
+    const out = [...this.satOut].map(([member, probability]) => `${MEMBER_LABELS[member]} sat out (${probability.toFixed(2)})`);
+    this.deps.feed?.log("CLASSIFIER", [`seated ${seated.length > 0 ? seated.map((member) => MEMBER_LABELS[member]).join(", ") : "nobody (the oracle plans alone)"}`, ...out, `${decision.ms} ms`].join(" · "), "info");
+    return seated;
+  }
+
+  /**
+   * Answer the round's questions the conversation already settles: the
+   * classifier's pick must be the recommended option, confident and clearly
+   * ahead. They leave the questionnaire and are recorded on the round's
+   * message, so every seat and the oracle read them as decided.
+   */
+  private async answerObvious(signal: AbortSignal): Promise<void> {
+    const jev = this.deps.classifier;
+    if (!jev?.enabled("answers")) return;
+    this.step = "checking for obvious answers";
+    this.deps.onChange?.();
+    const candidates = this.questions.map((question, index) => {
+      const recommended = recommendedOption(question);
+      return { index, from: question.from, text: question.text, options: question.options.map((option) => ({ label: optionLabel(option), description: option.description })), recommended: recommended ? optionLabel(recommended) : "" };
+    });
+    const decided = await autoAnswer(jev, candidates, { request: this.idea(), conversation: plannerTranscript(this.messages.slice(0, -1), this.seed, undefined, ""), ...(this.reply?.plan ? { draft: this.reply.plan } : {}) }, signal);
+    if (!decided || decided.length === 0 || signal.aborted) return;
+    const settled = new Set(decided.map((entry) => entry.index));
+    this.questions = this.questions.filter((_question, index) => !settled.has(index));
+    const last = this.messages.at(-1);
+    if (last?.role === "planner") {
+      const { questions: _asked, ...rest } = last;
+      const text = this.questions.length > 0 ? plannerSays(false, this.questions) : "The classifier settled this round's questions with the recommended options; the panel folds them in next.";
+      this.messages = [...this.messages.slice(0, -1), { ...rest, text, decided, ...(this.questions.length > 0 ? { questions: this.questions } : {}) }];
+    }
+    this.deps.feed?.log("CLASSIFIER", `answered ${decided.map((entry) => `[${entry.from}] ${entry.answer} (${entry.probability.toFixed(2)})`).join(", ")}; ${this.questions.length} left for you`, "info");
+  }
+
+  /**
+   * The oracle's reply sets the round's questions (chosen from the seats' and
+   * its own), verdict and draft. At and past the round limit nothing more is
+   * asked: any question the oracle still wrote is decided with its
+   * recommended option and recorded in the plan's Assumptions, and a plan
+   * that exists is READY.
+   */
+  private finishRound(outcomes: readonly MemberOutcome[], lead: RunOutcome, mode: RoundMode): void {
     const reply = lead.status === "success" ? parsePlannerReply(lead.output) : undefined;
     const seatQuestions = outcomes.flatMap((outcome) => (outcome.reply?.questions ?? []).map((question) => ({ ...question, from: MEMBER_LABELS[outcome.member] })));
-    const questions = roundQuestions(reply, seatQuestions);
+    let questions = roundQuestions(reply, seatQuestions);
     const seatsReady = outcomes.every((outcome) => outcome.reply?.status === "ready");
-    const ready = Boolean(reply && reply.status === "ready" && seatsReady);
+    let ready = Boolean(reply && reply.status === "ready" && seatsReady);
     if (reply) {
       // A round without a plan keeps the previous draft.
-      const plan = reply.plan ?? this.reply?.plan;
-      this.reply = { ...reply, status: ready ? "ready" : "grilling", ...(plan ? { plan } : {}) };
+      let plan = reply.plan ?? this.reply?.plan;
+      if (mode !== "normal") {
+        if (plan && questions.length > 0) {
+          plan = appendAssumptions(plan, questions, "decided at the round limit");
+          this.deps.feed?.log(ORACLE_LABEL, `round limit: decided ${questions.length} open question${questions.length === 1 ? "" : "s"} with the recommended option`, "info");
+        }
+        questions = [];
+        ready = Boolean(plan);
+      }
+      this.reply = { ...reply, status: ready ? "ready" : "grilling", ...(mode !== "normal" ? { questions: [] } : {}), ...(plan ? { plan } : {}) };
     } else {
       this.error = `the oracle's part of the round failed — ${lead.error ?? lead.status}`;
     }
     if (!reply && seatQuestions.length === 0) return;
     this.questions = ready ? [] : questions;
-    this.messages = [...this.messages, { role: "planner", text: plannerSays(ready, this.questions), at: Date.now(), ...(this.questions.length > 0 ? { questions: this.questions } : {}) }];
+    this.messages = [...this.messages, { role: "planner", text: plannerSays(ready, this.questions, mode), at: Date.now(), ...(this.questions.length > 0 ? { questions: this.questions } : {}) }];
   }
 }