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

package/src/lobby/quickfix.ts

@@ -10,13 +10,18 @@ import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } fr
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics, type MetricRecord } from "../state/metrics.ts";
 import type { LobbyFeed } from "./feed.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import type { Classifier } from "../classifier/classifier.ts";
+import { quickFixSize } from "../classifier/triage.ts";
+import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
 export const QUICK_FIX_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 
 export const QUICK_FIX_SOURCE = "QUICK FIX";
 
-export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout";
+/** `held`: the classifier judged the request a task, not a quick fix; it waits for you (r runs it anyway, t makes it a task). */
+export type QuickFixStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout" | "held";
 
 export interface QuickFixStep {
   at: number;
@@ -39,6 +44,13 @@ export interface QuickFixJob {
   report?: string;
   error?: string;
   usage?: { input: number; output: number; cost: number; turns: number };
+  /** Why the job was held, or what became of it. */
+  note?: string;
+  /** Run even if the classifier judges it large (r on a held job). */
+  force?: boolean;
+  /** The classifier routed it down (`trivial 0.88: p/big · low → p/cheap · low`); cleared when it re-ran on the configured profile. */
+  route?: string;
+  routedFrom?: string;
 }
 
 export interface QuickFixProfile {
@@ -61,6 +73,12 @@ export interface QuickFixDeps {
   /** Called after every change so the lobby can repaint. */
   onChange?: () => void;
   notify?: (message: string, level: "info" | "warning" | "error") => void;
+  /** Likely files for the prompt, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Holds a request it judges large (a task, not a quick fix) instead of spending a run on it. */
+  classifier?: Classifier;
+  /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
 export const MAX_JOBS = 30;
@@ -120,6 +138,30 @@ export class QuickFixQueue {
     return true;
   }
 
+  /** Run a held job anyway: it goes back in the queue and is not sized again. */
+  runAnyway(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "queued";
+    job.force = true;
+    delete job.note;
+    delete job.startedAt;
+    delete job.finishedAt;
+    this.changed();
+    this.pump();
+    return true;
+  }
+
+  /** A held job that became a task: it leaves the queue with a note. */
+  movedToTask(id: string): boolean {
+    const job = this.jobs.find((entry) => entry.id === id);
+    if (!job || job.status !== "held") return false;
+    job.status = "cancelled";
+    job.note = "started as a task in a new session";
+    this.changed();
+    return true;
+  }
+
   /** Abort everything (session shutdown). */
   cancelAll(): void {
     for (const job of this.jobs) if (job.status === "queued") job.status = "cancelled";
@@ -162,17 +204,23 @@ export class QuickFixQueue {
     job.startedAt = Date.now();
     job.thinking = profile.thinking;
     if (profile.model) job.model = profile.model;
-    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     this.changed();
+    const held = job.force ? undefined : await this.tooLarge(job, controller.signal);
+    if (held) {
+      this.controllers.delete(job.id);
+      return this.hold(job, held);
+    }
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     try {
-      const result = await runPiAgent(
+      const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
+      const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
-          task: job.prompt,
+          task: likely ? `${job.prompt}\n\n${likely}` : job.prompt,
           systemPrompt: quickFixPrompt(profile.instructions),
-          tools: QUICK_FIX_TOOLS,
-          model: profile.model,
-          thinking: profile.thinking,
+          tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
+          model,
+          thinking,
           timeoutMs: profile.timeoutMs,
           signal: controller.signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
@@ -181,6 +229,27 @@ export class QuickFixQueue {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
+      let result;
+      if (route) {
+        job.route = routeLabel(route);
+        job.routedFrom = profileLabel(route.from);
+        job.thinking = route.thinking;
+        if (route.model) job.model = route.model;
+        this.changed();
+        result = await attempt(route.model, route.thinking);
+        if (fellShort(result) && !controller.signal.aborted) {
+          // The routed attempt counts in the metrics on its own; the job re-runs on the configured profile.
+          appendMetrics(this.deps.root, this.deps.configDir, [{ ...quickFixMetric({ ...job, status: result.status, finishedAt: Date.now(), usage: result.usage, ...(result.model ? { model: result.model } : {}) }), id: `${job.id}-routed-${job.startedAt}` }]);
+          this.addStep(job, "the routed attempt fell short; running again on the configured model and thinking", Date.now());
+          delete job.route;
+          delete job.routedFrom;
+          job.thinking = profile.thinking;
+          if (profile.model) job.model = profile.model;
+          result = await attempt(profile.model, profile.thinking);
+        }
+      } else {
+        result = await attempt(profile.model, profile.thinking);
+      }
       job.status = result.status;
       job.report = result.output.trim() || undefined;
       job.error = result.error;
@@ -195,6 +264,48 @@ export class QuickFixQueue {
     }
   }
 
+  /** Where the classifier routes this request, or undefined. */
+  private async route(prompt: string, profile: QuickFixProfile, signal: AbortSignal): Promise<EffortRoute | undefined> {
+    try {
+      return await this.deps.effort?.route(prompt, { ...(profile.model ? { model: profile.model } : {}), thinking: profile.thinking }, { signal });
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Why a request is too large for a quick fix, when the classifier is sure; undefined runs it. */
+  private async tooLarge(job: QuickFixJob, signal: AbortSignal): Promise<string | undefined> {
+    const jev = this.deps.classifier;
+    if (!jev?.enabled("triage")) return undefined;
+    try {
+      const sized = await quickFixSize(jev, job.prompt, signal);
+      if (!sized || sized.size !== "large" || sized.confidence < jev.config.thresholds.quickFixLargeAt) return undefined;
+      return `looks like a task (large, ${sized.confidence.toFixed(2)})`;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Hold a job instead of running it; nothing ran, so nothing lands in the metrics. */
+  private hold(job: QuickFixJob, note: string): void {
+    job.status = "held";
+    job.note = note;
+    job.finishedAt = Date.now();
+    this.deps.feed?.log(QUICK_FIX_SOURCE, `held: ${jobTitle(job)} — ${note}; r runs it anyway, t makes it a task`, "warning", job.finishedAt);
+    this.deps.notify?.(`bot-lobby quick fix held: ${jobTitle(job)} ${note}`, "warning");
+    this.changed();
+    this.pump();
+  }
+
+  /** The Likely files block for a prompt, or "" (no hints, nothing stands out, out of time). */
+  private async likely(prompt: string, signal: AbortSignal): Promise<string> {
+    try {
+      return (await this.deps.hints?.block(prompt, signal)) ?? "";
+    } catch {
+      return "";
+    }
+  }
+
   private finish(job: QuickFixJob): void {
     job.finishedAt = Date.now();
     for (const step of job.steps) step.pending = false;
@@ -217,11 +328,12 @@ export function quickFixMetric(job: QuickFixJob): MetricRecord {
     agent: QUICK_FIX_SOURCE,
     ...(job.model ? { model: job.model } : {}),
     ...(job.thinking ? { thinking: job.thinking } : {}),
-    status: job.status === "queued" || job.status === "running" ? "failed" : job.status,
+    status: job.status === "queued" || job.status === "running" ? "failed" : job.status === "held" ? "cancelled" : job.status,
     startedAt: new Date(started).toISOString(),
     durationMs: Math.max(0, (job.finishedAt ?? started) - started),
     turns: job.usage?.turns || job.turns || undefined,
     tools: job.tools,
     ...(job.usage ? { input: job.usage.input, output: job.usage.output, cost: job.usage.cost } : {}),
+    ...(job.routedFrom ? { routedFrom: job.routedFrom } : {}),
   };
 }

package/src/lobby/runtime.ts

@@ -18,7 +18,7 @@ import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts
 import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
-import { appendMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
+import { appendMetrics, readClassifierMetrics, readMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, persistedRuns, setMinimized, setWidgetSuppressor, ZenScene, zenSnapshot } from "../pi/ui.ts";
 import { panelLines } from "../pi/zen.ts";
@@ -29,6 +29,8 @@ import { modelLookup } from "../pi/tools.ts";
 import { startPlannedTask, startTask } from "../pi/start-task.ts";
 import type { LobbyAgentKind, LobbyPanel, PanelMember } from "../schemas/configuration.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
+import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
+import { checkThinking } from "../pi/model-support.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, dialogAsker, loadAskTool, questionnaires, toolAsker, type Asker } from "./ask.ts";
@@ -415,6 +417,10 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
     profile: () => lobbyProfile(state, "planner"),
     memberProfile: (member) => seatProfile(state, member),
     panel: seats ?? config.lobby.planningPanel,
+    maxRounds: () => loadConfig().lobby.maxPlanningRounds,
+    classifier: classifier(),
+    hints: hintsFor({ cwd: state.ctx.cwd, root: state.root, configDir: state.configDir }),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(state.ctx)(model), thinking).level),
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
@@ -513,6 +519,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     plans: () => listPlannedTasks(state.root, state.configDir),
     comments: (taskId) => readPlanComments(state.root, state.configDir, taskId),
     metrics: () => readMetrics(state.root, state.configDir),
+    classifierMetrics: () => readClassifierMetrics(state.root, state.configDir),
     toOracle: (text) => toOracle(state, text),
     comment: (taskId, text) => addComment(state, taskId, text),
     startPlanned: (plan) => startPlanned(state, plan),
@@ -524,6 +531,7 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
     answerPanel: () => answerPanel(state),
     defaultPanel: () => loadConfig().lobby.planningPanel,
+    planningRounds: () => loadConfig().lobby.maxPlanningRounds,
     issuesEnabled: () => loadConfig().lobby.issues,
     panels: () => loadConfig().lobby.panels,
     savePanels: (panels) => savePanels(panels),
@@ -728,6 +736,9 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     notify: (message, level) => {
       if (!state.visible) ctx.ui.notify(message, level);
     },
+    hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    classifier: classifier(),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
   });
   runtime = state;
   lobbyFeed.clear();

package/src/lobby/tabs/metrics.ts

@@ -8,7 +8,7 @@
  */
 import { shortDuration } from "../../text.ts";
 import { tokens } from "../../pi/run-summary.ts";
-import type { GroupBy, MetricGroup, MetricRecord, SortKey, TaskStats, TaskTimeGroup } from "../../state/metrics.ts";
+import type { ClassifierSummary, GroupBy, MetricGroup, MetricRecord, SortKey, TaskStats, TaskTimeGroup } from "../../state/metrics.ts";
 import { bar, beside, bold, box, fill, fit, meter, notePane, paint, selectRow, sparkline, stackedBar, windowStart, wrap, type LobbyTheme, type PaneLayout } from "../layout.ts";
 import { sourceColor } from "./home.ts";
 
@@ -25,6 +25,8 @@ export interface MetricsTabInput {
   query?: string;
   /** Filled with where the table landed, for the wheel. */
   panes?: PaneLayout;
+  /** What the classifier did and spared, when it has run. */
+  classifier?: ClassifierSummary;
 }
 
 interface Column {
@@ -230,6 +232,27 @@ export function timeShare(records: readonly MetricRecord[], taskTimes: readonly
 }
 
 /** The metrics dashboard: KPI tiles, the charts, and the full table filling what is left. */
+/** Milliseconds as `180 ms` or `1.2s`: classifier calls are short. */
+function millis(ms: number): string {
+  return ms < 1000 ? `${Math.round(ms)} ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+/** The classifier's box: its calls and speed, then what its decisions spared. */
+export function classifierLines(summary: ClassifierSummary, width: number, theme?: LobbyTheme): string[] {
+  const inner = width - 4;
+  const purposes = Object.entries(summary.byPurpose).sort((a, b) => b[1] - a[1]).map(([purpose, count]) => `${purpose} ${count}`).join(" · ");
+  const calls = summary.calls > 0
+    ? [`${summary.calls} call${summary.calls === 1 ? "" : "s"}`, `${percent(summary.ok, summary.calls)} ok`, `p50 ${millis(summary.p50Ms)}`, `p90 ${millis(summary.p90Ms)}`, summary.input > 0 ? `${tokens(summary.input)} tokens read` : "", purposes].filter(Boolean).join(paint(theme, "dim", " · "))
+    : paint(theme, "dim", "no calls recorded");
+  const spared = [
+    `${summary.seatRunsSkipped} seat run${summary.seatRunsSkipped === 1 ? "" : "s"} skipped`,
+    `${summary.questionsAnswered} question${summary.questionsAnswered === 1 ? "" : "s"} answered`,
+    `${summary.quickFixesHeld} quick fix${summary.quickFixesHeld === 1 ? "" : "es"} held`,
+    summary.routed > 0 ? `${summary.routed} run${summary.routed === 1 ? "" : "s"} routed down, ${percent(summary.routedOk, summary.routed)} ok` : "no runs routed",
+  ].join(paint(theme, "dim", " · "));
+  return box(width, 4, [fit(calls, inner), fit(`${paint(theme, "success", "spared")} ${spared}`, inner)], { title: "Classifier (Jev)", theme });
+}
+
 export function renderMetrics(input: MetricsTabInput, width: number, height: number, theme?: LobbyTheme): string[] {
   if (height <= 0) return [];
   if (input.records.length === 0) {
@@ -242,6 +265,10 @@ export function renderMetrics(input: MetricsTabInput, width: number, height: num
     sections.push(...tileRow(input, width, theme));
     room -= 4;
   }
+  if (input.classifier && room >= 14) {
+    sections.push(...classifierLines(input.classifier, width, theme));
+    room -= 4;
+  }
   const chartHeight = Math.min(input.groups.length + 2, 8);
   if (room - chartHeight >= 9) {
     if (width >= 100) {

package/src/lobby/tabs/plan.ts

@@ -7,7 +7,7 @@
  * said the plan must respect.
  */
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
-import { ORACLE_LABEL, type LineComment, type PanelNote, type PanelQuestion, type PlannerMessage, type PlannerReply, type PlannerSeed } from "../planner.ts";
+import { ORACLE_LABEL, type LineComment, type PanelNote, type PanelQuestion, type PlannerMessage, type PlannerReply, type PlannerSeed, type RoundMode } from "../planner.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
 import { beside, bold, box, clock, fill, fit, italic, markdownLines, notePane, paint, selectRow, spinner, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "../layout.ts";
 import { sourceColor, speakerLine, tailWindow, youLines } from "./home.ts";
@@ -23,6 +23,10 @@ export interface SeatView {
   ready: boolean;
   /** `provider/model · thinking` the seat runs on. */
   profile?: string;
+  /** The classifier left it out of the latest round: how likely it judged the seat needed. */
+  satOut?: number;
+  /** Seated with a key press: it sits every round, whatever the classifier says. */
+  pinned?: boolean;
 }
 
 export interface PlanView {
@@ -35,6 +39,10 @@ export interface PlanView {
   step?: string;
   error?: string;
   turns: number;
+  /** Rounds before the oracle finalizes alone; 0 = unlimited. */
+  limit?: number;
+  /** How the next round will run under the limit. */
+  nextMode?: RoundMode;
   seed?: PlannerSeed;
   saved?: PlannedTask;
   title?: string;
@@ -79,6 +87,8 @@ export interface PlanTabInput {
   panes?: PaneLayout;
   /** The key that saves the plan, as the status line names it. */
   saveKey?: string;
+  /** The planning round limit before a session exists; 0 = unlimited. */
+  limit?: number;
 }
 
 export const PLAN_COLUMNS_MIN = 100;
@@ -91,19 +101,28 @@ function intro(input: PlanTabInput, width: number, theme?: LobbyTheme): string[]
     const model = seat.label === ORACLE_LABEL ? input.profile : seat.seated ? seat.profile ?? "" : "not seated";
     return fit(`${name}${paint(theme, seat.seated ? "muted" : "dim", model)}`, width);
   });
-  return [...wrap(bold(theme, "Describe a task below and the panel questions you until the plan is clear."), width), "", ...rows];
+  const bound = input.limit && input.limit > 0 ? ` (at most ${input.limit} rounds; the last one the oracle settles alone)` : "";
+  return [...wrap(bold(theme, `Describe a task below and the panel questions you until the plan is clear${bound}.`), width), "", ...rows];
+}
+
+/** `round 3/5`, `final round 5/5` or `round 6 · revising` under a limit; `round 3` without one. */
+export function roundLabel(turns: number, limit = 0): string {
+  if (limit <= 0) return `round ${turns}`;
+  if (turns > limit) return `round ${turns} · past the limit, revising`;
+  return turns === limit ? `final round ${turns}/${limit}` : `round ${turns}/${limit}`;
 }
 
 function statusLine(view: PlanView, input: PlanTabInput, theme?: LobbyTheme): string {
   const parts: string[] = [];
   const count = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
-  if (view.busy) parts.push(`${paint(theme, "accent", spinner(input.tick))} round ${view.turns}`);
+  if (view.busy) parts.push(`${paint(theme, "accent", spinner(input.tick))} ${roundLabel(view.turns, view.limit)}`);
   else if (view.error) parts.push(paint(theme, "error", `✗ ${view.error.split("\n")[0]} — r retries`));
   else if (view.reply?.status === "ready") parts.push(paint(theme, "success", `✓ ready — ${input.saveKey ?? "Ctrl+S"} saves it`));
   else if (view.awaitingAnswers) parts.push(paint(theme, "warning", `● ${count(view.questions.length, "question")} — enter ${view.answeredChunks > 0 ? "resumes" : "answers them"}`));
   if (view.lineComments.length > 0) parts.push(paint(theme, "accent", `◆ ${count(view.lineComments.length, "comment")} to send`));
   if (view.saved) parts.push(paint(theme, "success", `saved as ${view.saved.id}`));
-  if (!view.busy && view.turns > 0) parts.push(paint(theme, "dim", `round ${view.turns}`));
+  if (!view.busy && view.turns > 0) parts.push(paint(theme, "dim", roundLabel(view.turns, view.limit)));
+  if (!view.busy && view.nextMode === "final") parts.push(paint(theme, "warning", "the next round is the last: the oracle settles the rest"));
   return parts.join(paint(theme, "dim", " · "));
 }
 
@@ -111,6 +130,7 @@ function statusLine(view: PlanView, input: PlanTabInput, theme?: LobbyTheme): st
 function seatCell(seat: SeatView, tick: number, theme?: LobbyTheme): string {
   const name = paint(theme, seat.seated ? sourceColor(seat.label) : "dim", seat.label);
   if (!seat.seated) return `${name} ${paint(theme, "dim", "off")}`;
+  if (seat.satOut !== undefined && seat.status !== "thinking") return `${name} ${paint(theme, "dim", `sat out · ${seat.satOut.toFixed(2)}`)}`;
   if (seat.status === "thinking") return `${name} ${paint(theme, "accent", spinner(tick))} ${paint(theme, "muted", seat.step ?? "thinking")}`;
   if (seat.status === "failed") return `${name} ${paint(theme, "error", "✗ failed — r retries")}`;
   if (seat.status === "idle") return `${name} ${paint(theme, "dim", "·")}`;
@@ -159,6 +179,9 @@ export function conversationLines(view: PlanView, width: number, theme?: LobbyTh
     }
     lines.push(speakerLine("panel", width, theme, time));
     lines.push(...(questions.length > 0 ? questionLines(questions, width, theme) : wrap(message.text, width).map((line) => (line ? `  ${line}` : ""))));
+    for (const entry of message.decided ?? []) {
+      lines.push(...wrapHanging(`  ${paint(theme, "success", "✓")} `, `${paint(theme, sourceColor(entry.from), `[${entry.from}]`)} ${entry.question} → ${bold(theme, entry.answer)} ${paint(theme, "dim", `· decided by the classifier (${entry.probability.toFixed(2)}); comment on the plan to overrule`)}`, width));
+    }
   }
   if (query && lines.length === 0) return wrap(paint(theme, "dim", `Nothing in the conversation matches "${query}".`), width);
   return lines;

package/src/lobby/tabs/quickfix.ts

@@ -31,6 +31,7 @@ const STATUS_COLORS: Record<QuickFixJob["status"], "accent" | "success" | "error
   failed: "error",
   timeout: "error",
   cancelled: "warning",
+  held: "warning",
 };
 
 function mark(job: QuickFixJob, tick: number, theme?: LobbyTheme): string {
@@ -38,6 +39,7 @@ function mark(job: QuickFixJob, tick: number, theme?: LobbyTheme): string {
   if (job.status === "queued") return paint(theme, "muted", "…");
   if (job.status === "success") return paint(theme, "success", "✓");
   if (job.status === "cancelled") return paint(theme, "warning", "·");
+  if (job.status === "held") return paint(theme, "warning", "‖");
   return paint(theme, "error", "✗");
 }
 
@@ -60,8 +62,10 @@ export function jobDetailLines(job: QuickFixJob, width: number, tick: number, no
     job.usage?.cost ? `$${job.usage.cost.toFixed(2)}` : "",
   ].filter(Boolean);
   const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...wrap(bold(theme, job.prompt), width)];
+  if (job.route) lines.push("", ...wrap(paint(theme, "dim", `↓ routed ${job.route}`), width));
+  if (job.note) lines.push("", ...wrap(paint(theme, "warning", job.status === "held" ? `‖ Held: ${job.note}. r runs it anyway · t starts it as a task in a new session.` : job.note), width));
   lines.push("", rule(width, "Steps", theme));
-  if (job.steps.length === 0) lines.push(paint(theme, "dim", job.status === "queued" ? "Waiting for the quick fix ahead of it." : job.status === "running" ? `${spinner(tick)} starting…` : "No tool calls."));
+  if (job.steps.length === 0) lines.push(paint(theme, "dim", job.status === "queued" ? "Waiting for the quick fix ahead of it." : job.status === "running" ? `${spinner(tick)} starting…` : job.status === "held" ? "Not started." : "No tool calls."));
   for (const step of job.steps) {
     const lead = `${paint(theme, "dim", clock(step.at))} ${step.pending && job.status === "running" ? paint(theme, "accent", spinner(tick)) : paint(theme, "dim", "·")} `;
     lines.push(...wrapHanging(lead, step.pending && job.status === "running" ? `${step.text}…` : paint(theme, "muted", step.text), width));

package/src/lobby/view.ts

@@ -14,7 +14,7 @@ import { TERMINAL_STATES, 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 { aggregateMetrics, collectMetrics, SORT_KEYS, sortGroups, taskStats, taskTimesByModel, type GroupBy, type MetricRecord, type SortKey } from "../state/metrics.ts";
+import { aggregateMetrics, collectMetrics, SORT_KEYS, sortGroups, summarizeClassifier, taskStats, taskTimesByModel, type GroupBy, type MetricRecord, type SortKey } from "../state/metrics.ts";
 import { PANEL_MEMBERS, type LobbyAgentKind, type LobbyPanel, type PanelMember } from "../schemas/configuration.ts";
 import type { ChatEntry, LobbyFeed } from "./feed.ts";
 import type { BackgroundSession } from "./sessions.ts";
@@ -133,6 +133,8 @@ export interface LobbyHost {
   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;
@@ -148,6 +150,8 @@ export interface LobbyHost {
   answerPanel(): 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;
@@ -336,12 +340,13 @@ export class LobbyView implements Component, Focusable {
 
   /** The Tasks tab lists archived tasks too (v). */
   showArchived = false;
-  private data: { tasks: Task[]; plans: PlannedTask[]; archived: Task[]; comments: Map<string, PlanComment[]>; metrics: MetricRecord[]; at: number } = {
+  private data: { tasks: Task[]; plans: PlannedTask[]; archived: Task[]; comments: Map<string, PlanComment[]>; metrics: MetricRecord[]; classifierMetrics: MetricRecord[]; at: number } = {
     tasks: [],
     plans: [],
     archived: [],
     comments: new Map(),
     metrics: [],
+    classifierMetrics: [],
     at: 0,
   };
 
@@ -431,6 +436,7 @@ export class LobbyView implements Component, Focusable {
       archived: this.showArchived ? this.host.archivedTasks() : [],
       comments: new Map(),
       metrics: this.tab === "metrics" ? this.host.metrics() : this.data.metrics,
+      classifierMetrics: this.tab === "metrics" ? this.host.classifierMetrics?.() ?? [] : this.data.classifierMetrics,
       at: now,
     };
     if (this.tab === "tasks") {
@@ -998,6 +1004,17 @@ export class LobbyView implements Component, Focusable {
           return true;
         }
         if (data === "m") return this.openSettings("quickfix"), true;
+        if (data === "r" || data === "t") {
+          const job = this.fixJobs()[this.fixSelected];
+          // Only a held job takes r and t; otherwise the key resumes typing like any other.
+          if (!job || job.status !== "held") return false;
+          if (data === "r" && this.host.quickfix.runAnyway(job.id)) this.say(`running ${job.id} anyway`);
+          if (data === "t") {
+            this.startInNewSession({ request: job.prompt });
+            this.host.quickfix.movedToTask(job.id);
+          }
+          return true;
+        }
         return false;
       case "issues":
         return this.issuesCommand(data, enter, escape);
@@ -1433,7 +1450,7 @@ export class LobbyView implements Component, Focusable {
         seated = !seats.delete(seat);
         if (seated) seats.add(seat);
       }
-      this.say(`${MEMBER_LABELS[seat]} ${seated ? "joins" : "leaves"} the panel from the next round`);
+      this.say(`${MEMBER_LABELS[seat]} ${seated ? "joins the panel from the next round and sits every round" : "leaves the panel from the next round"}`);
       return true;
     }
     if (data === "x" || (escape && session?.busy)) {
@@ -1901,6 +1918,7 @@ export class LobbyView implements Component, Focusable {
         break;
       case "quickfix":
         if (this.host.quickfix.jobs.length > 0) keys.push(["↑↓", "select"], ["x", "cancel"]);
+        if (this.fixJobs()[this.fixSelected]?.status === "held") keys.push(["r", "run anyway"], ["t", "as a task"]);
         keys.push(["m", "model"]);
         break;
       case "issues":
@@ -1971,6 +1989,7 @@ export class LobbyView implements Component, Focusable {
           ...(session ? { session: this.planView(session) } : {}),
           profile: this.host.profileLabel("planner"),
           seats: this.seatViews(undefined),
+          limit: this.host.planningRounds?.() ?? 0,
           offset: this.planOffset,
           focus: this.planFocus,
           draftOffset: this.planDraftOffset,
@@ -2003,7 +2022,8 @@ export class LobbyView implements Component, Focusable {
         const groups = sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort);
         this.metricsSelected = Math.min(this.metricsSelected, Math.max(0, groups.length - 1));
         const taskTimes = taskTimesByModel(this.data.tasks, records);
-        return renderMetrics({ groups, taskTimes, records, stats: taskStats(this.data.tasks), by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes }, width, height, theme);
+        const jev = summarizeClassifier(this.data.classifierMetrics, records);
+        return renderMetrics({ groups, taskTimes, records, stats: taskStats(this.data.tasks), by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
       }
     }
   }
@@ -2034,6 +2054,8 @@ export class LobbyView implements Component, Focusable {
         questions: session?.questions.filter((question) => question.from === MEMBER_LABELS[member]).length ?? 0,
         ready: state?.reply?.status === "ready",
         profile: this.host.seatLabel(member),
+        ...(!state && session?.satOut.has(member) ? { satOut: session.satOut.get(member)! } : {}),
+        ...(session?.pins.has(member) ? { pinned: true } : {}),
       };
     });
     return [oracle, ...members];
@@ -2050,6 +2072,8 @@ export class LobbyView implements Component, Focusable {
       ...(session.step ? { step: session.step } : {}),
       ...(session.error ? { error: session.error } : {}),
       turns: session.turns,
+      limit: session.limit,
+      nextMode: session.nextMode,
       ...(session.seed ? { seed: session.seed } : {}),
       ...(session.saved ? { saved: session.saved } : {}),
       ...(session.title ? { title: session.title } : {}),