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

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/tabs/tasks.ts

@@ -13,13 +13,14 @@ import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
 import { ago, beside, bold, box, detailWindow, fill, markdownLines, notePane, paint, position, rule, selectRow, since, spread, strike, windowStart, wrap, wrapHanging, type LobbyColor, type LobbyTheme, type PaneLayout } from "../layout.ts";
 
-export type TaskSection = "mine" | "others" | "pending" | "recent";
+export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
 /** How a row is ticked off: still to do (a plan, or a task under way), completed, or abandoned. */
 export type CheckState = "open" | "done" | "dropped";
 
 export interface TaskRow {
-  kind: "task" | "plan";
+  /** A task on the list, a saved plan, or a task in the archive. */
+  kind: "task" | "plan" | "archived";
   id: string;
   title: string;
   section: TaskSection;
@@ -31,7 +32,7 @@ export interface TaskRow {
   progress?: { done: number; total: number };
   /** Who drives it, for tasks other sessions own. */
   owner?: string;
-  /** How long ago it finished (finished tasks) or was saved (plans), as `3h`. */
+  /** How long ago it finished (finished tasks), was saved (plans) or was archived, as `3h`. */
   age?: string;
   /** The GitHub issue a plan came from. */
   issue?: number;
@@ -45,6 +46,10 @@ export interface RowContext {
   names?: ReadonlyMap<string, string>;
   /** Tasks with auto mode on. */
   auto?: ReadonlySet<string>;
+  /** Sessions running now (from their heartbeats); a task whose owner is not among them says so. */
+  live?: ReadonlySet<string>;
+  /** Archived tasks, listed last when shown. */
+  archived?: readonly Task[];
 }
 
 export const SECTION_TITLES: Record<TaskSection, string> = {
@@ -52,6 +57,7 @@ export const SECTION_TITLES: Record<TaskSection, string> = {
   others: "OTHER SESSIONS",
   pending: "PENDING",
   recent: "FINISHED",
+  archived: "ARCHIVED",
 };
 
 /** The box each row wears: empty while there is work to do, ticked when completed, crossed when abandoned. */
@@ -63,9 +69,6 @@ export function checkState(task: Task): CheckState {
   return "open";
 }
 
-/** Finished tasks listed under RECENT. */
-export const RECENT_LIMIT = 8;
-
 /** Checklist progress as `3/7`, or undefined before a plan exists. */
 export function taskProgress(task: Task): { done: number; total: number } | undefined {
   if (!task.plan) return undefined;
@@ -74,13 +77,14 @@ export function taskProgress(task: Task): { done: number; total: number } | unde
   return { done: steps.filter((step) => step.status === "done").length, total: steps.length };
 }
 
-function ownerLabel(task: Task, sessionId: string | undefined, names?: ReadonlyMap<string, string>): string {
-  if (!task.ownerSessionId) return "no owner";
+function ownerLabel(task: Task, sessionId: string | undefined, names?: ReadonlyMap<string, string>, live?: ReadonlySet<string>): string {
+  if (!task.ownerSessionId) return "not running";
   if (task.ownerSessionId === sessionId) return "this session";
   const name = names?.get(task.ownerSessionId);
   // A background session is named after its task, so the row's title already says which one.
   if (name) return name === task.title ? "background" : `background · ${name}`;
-  return `session ${task.ownerSessionId.slice(0, 8)}`;
+  // An ended session's id tells nobody anything: say that nothing runs the task.
+  return live && !live.has(task.ownerSessionId) ? "not running" : `session ${task.ownerSessionId.slice(0, 8)}`;
 }
 
 /** Rows in display order: this session's task, other sessions', pending plans, then recent finished tasks. */
@@ -98,7 +102,7 @@ export function taskRows(tasks: readonly Task[], plans: readonly PlannedTask[],
       ...(task.paused && section !== "recent" ? { paused: true } : {}),
       check: checkState(task),
       ...(progress ? { progress } : {}),
-      ...(section === "others" ? { owner: ownerLabel(task, sessionId, context.names) } : {}),
+      ...(section === "others" ? { owner: ownerLabel(task, sessionId, context.names, context.live) } : {}),
       ...(section === "recent" ? { age: ago(now - Date.parse(task.updatedAt)) } : {}),
       ...(auto ? { auto: true } : {}),
     };
@@ -116,7 +120,16 @@ export function taskRows(tasks: readonly Task[], plans: readonly PlannedTask[],
       ...(plan.createdAt ? { age: ago(now - Date.parse(plan.createdAt)) } : {}),
       ...(plan.issue ? { issue: plan.issue.number } : {}),
     })),
-    ...tasks.filter((task) => TERMINAL_STATES.includes(task.state)).slice(0, RECENT_LIMIT).map((task) => row(task, "recent")),
+    ...tasks.filter((task) => TERMINAL_STATES.includes(task.state)).map((task) => row(task, "recent")),
+    ...(context.archived ?? []).map((task): TaskRow => ({
+      kind: "archived",
+      id: task.id,
+      title: task.title,
+      section: "archived",
+      status: task.state,
+      check: checkState(task),
+      age: ago(now - Date.parse(task.archivedAt ?? task.updatedAt)),
+    })),
   ];
 }
 
@@ -151,6 +164,7 @@ export function checkMark(row: Pick<TaskRow, "check" | "status" | "paused">, the
 /** A title as its box says: struck through and dim once abandoned, bold while selected. */
 function rowTitle(row: TaskRow, selected: boolean, theme?: LobbyTheme): string {
   if (row.check === "dropped") return paint(theme, "dim", strike(theme, row.title));
+  if (row.kind === "archived") return selected ? bold(theme, row.title) : paint(theme, "dim", row.title);
   if (row.check === "done") return selected ? bold(theme, row.title) : paint(theme, "muted", row.title);
   return selected ? bold(theme, row.title) : row.title;
 }
@@ -216,9 +230,11 @@ export function listLines(rows: readonly TaskRow[], selected: number, width: num
 /** The list pane's right-hand count: what is open and what is finished, or how many rows match a search. */
 export function listCount(rows: readonly TaskRow[], query?: string): string {
   if (query) return `${rows.length} match${rows.length === 1 ? "" : "es"}`;
-  const open = rows.filter((row) => row.check === "open").length;
-  const finished = rows.length - open;
-  return [open ? `${open} open` : "", finished ? `${finished} finished` : ""].filter(Boolean).join(" · ") || "0";
+  const listed = rows.filter((row) => row.kind !== "archived");
+  const open = listed.filter((row) => row.check === "open").length;
+  const finished = listed.length - open;
+  const archived = rows.length - listed.length;
+  return [open ? `${open} open` : "", finished ? `${finished} finished` : "", archived ? `${archived} archived` : ""].filter(Boolean).join(" · ") || "0";
 }
 
 const COMMENT_MARKS: Record<PlanComment["status"], string> = { open: "○", delivered: "◐", addressed: "✓" };