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

package/src/lobby/view.ts

@@ -9,12 +9,13 @@
  * pane toggles, paging) work in both. Everything bot-lobby-specific arrives
  * through `LobbyHost`, so the view renders and reacts the same in tests.
  */
-import { decodeKittyPrintable, Editor, Input, Key, matchesKey, visibleWidth, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, Editor, Input, Key, matchesKey, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { textWidth } from "../width.ts";
 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";
@@ -23,7 +24,7 @@ import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } f
 import { issueText, type IssuesState } from "./issues.ts";
 import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, type KeyMap, type LobbyAction } from "./keys.ts";
 import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "./layout.ts";
-import { chatLines, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
+import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
 import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
 import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
 import { filterJobs, newestFirst, renderQuickFix } from "./tabs/quickfix.ts";
@@ -113,6 +114,9 @@ function sameView(a: SessionView, b: SessionView): boolean {
   return true;
 }
 
+/** Tops a conversation whose earlier messages are not in memory. */
+export const OLDER_NOTE = "↑ earlier messages load as you scroll up";
+
 const SECTION_OF: Record<SessionWhere, string> = { "this window": "THIS WINDOW", background: "BACKGROUND", "other terminal": "OTHER TERMINALS", "not running": "NOT RUNNING" };
 const WHERE_MARKS: Record<SessionWhere, string> = { "this window": "●", background: "◆", "other terminal": "◇", "not running": "○" };
 
@@ -133,6 +137,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 +154,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;
@@ -185,8 +193,12 @@ export interface LobbyHost {
   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. */
+  /** 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[];
   /** A task's status without animations, for a session other than this window's. */
   taskScene(task: Task, width: number, height: number): string[];
   profileLabel(kind: LobbyAgentKind): string;
@@ -212,7 +224,7 @@ class LobbyEditor extends Editor {
     if (!this.label) return super.renderTopBorder(width, hiddenLineCount);
     const label = ` ${this.label} `;
     const more = hiddenLineCount > 0 ? ` ↑${hiddenLineCount} ` : "";
-    const rest = width - 2 - visibleWidth(label) - visibleWidth(more);
+    const rest = width - 2 - textWidth(label) - textWidth(more);
     if (rest < 1) return super.renderTopBorder(width, hiddenLineCount);
     return `${this.borderColor("──")}${this.paintLabel(label)}${this.borderColor("─".repeat(rest))}${more ? this.borderColor(more) : ""}`;
   }
@@ -336,12 +348,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,
   };
 
@@ -425,12 +438,14 @@ export class LobbyView implements Component, Focusable {
   refreshData(force: boolean): void {
     const now = this.now();
     if (!force && now - this.data.at < DATA_REFRESH_MS) return;
+    this.dataVersion += 1;
     this.data = {
       tasks: this.host.tasks(),
       plans: this.host.plans(),
       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") {
@@ -832,6 +847,7 @@ export class LobbyView implements Component, Focusable {
         break;
     }
     this.clampScroll();
+    if (pane === "conversation") this.followHistory();
   }
 
   /** Home and End: the oldest or first line of the focused pane, or back to its newest or last. */
@@ -855,6 +871,8 @@ export class LobbyView implements Component, Focusable {
       return;
     }
     this.scrollPane(pane, far);
+    // Home loads earlier messages at the top; go on to the very first of them.
+    if (start && pane === "conversation" && this.history) this.homeOffsets.conversation = Number.MAX_SAFE_INTEGER;
   }
 
   /** The wheel over the draft scrolls it; the cursor follows only when it would leave the screen. */
@@ -948,7 +966,9 @@ export class LobbyView implements Component, Focusable {
     const rows = this.taskRowList();
     this.tasksSelected = Math.max(0, Math.min(rows.length - 1, index));
     this.tasksDetailOffset = 0;
-    this.refreshData(true);
+    // Only the newly selected task's comments: moving through the list must not reread every task from disk.
+    const row = rows[this.tasksSelected];
+    if (row?.kind === "task" && !this.data.comments.has(row.id)) this.data.comments.set(row.id, this.host.comments(row.id));
   }
 
   private async loadIssueDetail(): Promise<void> {
@@ -998,6 +1018,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);
@@ -1188,6 +1219,50 @@ export class LobbyView implements Component, Focusable {
     void this.host.answerDialog(session).then(() => this.host.requestRender());
   }
 
+  /* -------------------------------------------------------------- history */
+
+  /**
+   * The whole conversation of the session in view, loaded when the
+   * conversation pane is scrolled back past the messages kept in memory, and
+   * let go once it is back at the newest.
+   */
+  private history?: { view: SessionView; entries: readonly ChatEntry[] };
+
+  /** The conversation to draw for the session in view, and whether earlier messages wait to be loaded. */
+  private conversationFor(entry: SessionEntry): { chat: readonly ChatEntry[]; older: boolean } {
+    if (this.history && sameView(this.history.view, entry.view)) return { chat: this.history.entries, older: false };
+    if (entry.view.kind === "here") return { chat: this.host.feed.chat, older: this.host.feed.chatOlder };
+    if (entry.view.kind === "background") {
+      const session = this.viewedSessionFor(entry.view.key);
+      return { chat: session?.feed.chat ?? [], older: Boolean(session?.feed.chatOlder && session.sessionId) };
+    }
+    return entry.sessionId ? { chat: this.host.sessionChat(entry.sessionId), older: this.host.hasOlderChat(entry.sessionId) } : { chat: [], older: false };
+  }
+
+  /**
+   * After the conversation pane scrolls: at its top, with earlier messages
+   * waiting, load the whole conversation; back at its newest, let it go.
+   * True when history was loaded now.
+   */
+  private followHistory(): boolean {
+    if (this.tab !== "lobby") return false;
+    if (this.homeOffsets.conversation === 0) {
+      this.history = undefined;
+      return false;
+    }
+    if (this.history && sameView(this.history.view, this.viewing)) return false;
+    const pane = this.panes.get("conversation");
+    if (!pane || this.homeOffsets.conversation < pane.total - pane.rows) return false;
+    const entry = this.viewedEntry();
+    if (!this.conversationFor(entry).older) return false;
+    const sessionId = entry.view.kind === "here" ? undefined : entry.view.kind === "background" ? this.viewedSessionFor(entry.view.key)?.sessionId : entry.sessionId;
+    if (entry.view.kind !== "here" && !sessionId) return false;
+    const entries = this.host.chatHistory(sessionId);
+    if (entries.length === 0) return false;
+    this.history = { view: entry.view, entries };
+    return true;
+  }
+
   /* ------------------------------------------------------------ sessions */
 
   /** Every session the lobby can show: this window, the background sessions it started, then tasks other terminals drive. */
@@ -1253,6 +1328,7 @@ export class LobbyView implements Component, Focusable {
     this.viewing = target;
     this.picking = false;
     this.newSession = false;
+    this.history = undefined;
     for (const pane of HOME_PANES) this.homeOffsets[pane] = 0;
     if (this.tab !== "lobby") this.setTab("lobby");
     this.setMode("type");
@@ -1433,7 +1509,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)) {
@@ -1640,8 +1716,41 @@ export class LobbyView implements Component, Focusable {
 
   /* -------------------------------------------------------------- render */
 
+  /** Bumped each time the data is reread. */
+  private dataVersion = 0;
+  /** Task rows as last built: several parts of a frame ask, and they only change with the data, the search or the clock. */
+  private rowsMemo?: { key: string; rows: TaskRow[] };
+
+  /** The Metrics tab's figures as last computed: they change only with the data, the grouping, the order or the search. */
+  private metricsMemo?: { key: string; figures: ReturnType<LobbyView["computeMetrics"]> };
+
+  private metricsFigures(query: string | undefined) {
+    const key = `${this.dataVersion}|${this.metricsBy}|${this.metricsSort}|${query ?? ""}`;
+    if (this.metricsMemo?.key !== key) this.metricsMemo = { key, figures: this.computeMetrics(query) };
+    return this.metricsMemo.figures;
+  }
+
+  private computeMetrics(query: string | undefined) {
+    const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
+    return {
+      records,
+      groups: sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort),
+      taskTimes: taskTimesByModel(this.data.tasks, records),
+      stats: taskStats(this.data.tasks),
+      jev: summarizeClassifier(this.data.classifierMetrics, records),
+    };
+  }
+
   /** Task rows, narrowed by the Tasks tab's search. */
   private taskRowList(): TaskRow[] {
+    const key = `${this.dataVersion}|${this.tick}|${this.showArchived}|${this.queries.tasks ?? ""}`;
+    if (this.rowsMemo?.key === key) return this.rowsMemo.rows;
+    const rows = this.buildTaskRows();
+    this.rowsMemo = { key, rows };
+    return rows;
+  }
+
+  private buildTaskRows(): TaskRow[] {
     const names = new Map<string, string>();
     for (const session of this.host.sessions()) if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
     const auto = new Set(this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && this.host.isAuto(task.id)).map((task) => task.id));
@@ -1674,12 +1783,12 @@ export class LobbyView implements Component, Focusable {
       const badge = badges[tab] ? ` ${paint(theme, tab === "plan" && session?.awaitingAnswers ? "warning" : "accent", badges[tab]!)}` : "";
       let cell = ` ${number} ${name}${badge} `;
       if (tab === this.tab) cell = theme.bg ? theme.bg("selectedBg", cell) : `[${cell}]`;
-      const from = visibleWidth(left);
+      const from = textWidth(left);
       left += cell;
-      spans.push({ tab, from, to: visibleWidth(left) });
+      spans.push({ tab, from, to: textWidth(left) });
     }
     this.tabSpans = spans;
-    const room = width - visibleWidth(left) - 1;
+    const room = width - textWidth(left) - 1;
     const entry = this.viewedEntry();
     const help = paint(theme, "dim", `${keyLabel(this.keys.help)} keys `);
     const auto = entry.auto ? ` ${bold(theme, paint(theme, "success", "⟳ AUTO"))}` : "";
@@ -1700,8 +1809,8 @@ export class LobbyView implements Component, Focusable {
         ? [`${dot} ${zen.task.id} ${state}${auto}${asking}  ${help}`, `${dot} ${zen.task.id} ${state}${auto}${asking} `, `${dot} ${state}${auto} `, `${dot}${auto} `]
         : [`${paint(theme, "dim", "no task in this session")}${asking}  ${help}`, `${paint(theme, "dim", "no task in this session")}${asking} `, help, ""];
     }
-    const status = choices.find((choice) => visibleWidth(choice) <= room) ?? "";
-    const gap = width - visibleWidth(left) - visibleWidth(status);
+    const status = choices.find((choice) => textWidth(choice) <= room) ?? "";
+    const gap = width - textWidth(left) - textWidth(status);
     return gap >= 1 ? `${left}${" ".repeat(gap)}${status}` : fit(left, width);
   }
 
@@ -1763,7 +1872,7 @@ export class LobbyView implements Component, Focusable {
     const tail = this.searching
       ? paint(theme, "dim", " enter keep · esc clear · ↑↓ browse results ")
       : paint(theme, "dim", ` ${keyLabel(this.keys.search)} or / edits · esc clears `);
-    const room = Math.max(4, width - visibleWidth(lead) - visibleWidth(tail));
+    const room = Math.max(4, width - textWidth(lead) - textWidth(tail));
     const field = this.searching ? this.search.render(room)[0] ?? "" : bold(theme, fit(query ?? "", room));
     return [fit(`${lead}${fit(field, room)}${tail}`, width)];
   }
@@ -1901,6 +2010,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 +2081,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,
@@ -1999,11 +2110,9 @@ export class LobbyView implements Component, Focusable {
         }, width, height, theme);
       }
       case "metrics": {
-        const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
-        const groups = sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort);
+        const { records, groups, taskTimes, stats, jev } = this.metricsFigures(query);
         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);
+        return renderMetrics({ groups, taskTimes, records, stats, by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
       }
     }
   }
@@ -2034,6 +2143,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 +2161,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 } : {}),
@@ -2126,7 +2239,7 @@ export class LobbyView implements Component, Focusable {
     const room = height - lines.length - 2;
     if (room > 2) {
       lines.push("", rule(width, "Conversation", theme));
-      const talk = chat.length > 0 ? chatLines(chat, width, theme) : [paint(theme, "dim", "Nothing said yet.")];
+      const talk = chat.length > 0 ? chatTail(chat, width, theme, room - 1).lines : [paint(theme, "dim", "Nothing said yet.")];
       lines.push(...talk.slice(-(room - 1)));
     }
     return lines;
@@ -2151,9 +2264,11 @@ export class LobbyView implements Component, Focusable {
     const query = this.query();
     const entry = this.viewedEntry();
     if (entry.view.kind !== "here") return this.otherSessionBody(entry, width, height, theme, now);
+    const talk = this.conversationFor(entry);
     return renderHome({
       ...(zen.task ? { task: zen.task, scene: (w: number, h: number, animated: boolean) => this.host.scene(w, h, animated) } : {}),
-      chat: feed.chat,
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       ...(feed.reply ? { liveReply: feed.reply } : {}),
       activity: feed.activity,
       thoughts: feed.thoughts,
@@ -2183,6 +2298,7 @@ export class LobbyView implements Component, Focusable {
    */
   private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
     const session = this.viewedSession();
+    const talk = this.conversationFor(entry);
     const task = entry.task;
     const query = this.query();
     const common = {
@@ -2208,7 +2324,8 @@ export class LobbyView implements Component, Focusable {
       const emptyNote = session.status === "starting" ? `starting ${session.name}…` : !session.alive ? `${session.name} has ended.` : `${session.name} has not said anything yet.`;
       return renderHome({
         ...common,
-        chat: session.feed.chat,
+        chat: talk.chat,
+        ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
         ...(session.feed.reply ? { liveReply: session.feed.reply } : {}),
         activity: session.feed.activity,
         thoughts: session.feed.thoughts,
@@ -2219,7 +2336,8 @@ export class LobbyView implements Component, Focusable {
     const running = entry.where === "other terminal";
     return renderHome({
       ...common,
-      chat: entry.sessionId ? this.host.sessionChat(entry.sessionId) : [],
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       activity: [],
       thoughts: [],
       busy: false,

package/src/master/master.ts

@@ -13,6 +13,8 @@ import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
 import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
 import { truncate } from "../text.ts";
 import { isScoutResultUsable, parseScoutResult, validateScoutResult } from "../roles/scout.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 export interface ScoutOutcome {
   result: ScoutResult;
@@ -36,6 +38,10 @@ export interface ScoutRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Likely files for each scout's context, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Moves a trivial scout to the cheaper model, while the classifier's effort routing is on. */
+  effort?: EffortRouter;
 }
 
 /** Model, thinking and time limit for one run, from settings. */
@@ -53,16 +59,41 @@ function scoutInstruction(request: ScoutRequest, domain: Domain): string {
   ].join("\n");
 }
 
-function scoutContext(request: ScoutRequest, domain: Domain): AgentRequest["context"] {
+function scoutContext(request: ScoutRequest, domain: Domain, likely = ""): AgentRequest["context"] {
   const slices = readAgentKnowledge(request.dataRoots, domain);
   return {
     task: request.taskText,
     ...selectKnowledge(`${request.taskText} ${domainSpec(domain).scoutFocus}`, slices),
     instructions: request.config.agents[domain].instructions,
-    workflowContext: `Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`,
+    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, likely].filter(Boolean).join("\n\n"),
   };
 }
 
+/** Where the classifier routes a run, or undefined (no router, no route, a failure). */
+async function routeFor(effort: EffortRouter | undefined, instruction: string, profile: { model?: string; thinking: string }, options: { thinkingFixed?: boolean; context?: string; signal?: AbortSignal }): Promise<EffortRoute | undefined> {
+  if (!effort) return undefined;
+  try {
+    return await effort.route(instruction, profile, options);
+  } catch {
+    return undefined;
+  }
+}
+
+/** The run fields a route changes: model, thinking, no in-place retry (the fallback is the retry), and its label. */
+function routedFields(route: EffortRoute): Pick<AgentRequest, "model" | "thinking" | "retries" | "routedFrom" | "route"> {
+  return { model: route.model, thinking: route.thinking, retries: 0, routedFrom: profileLabel(route.from), route: routeLabel(route) };
+}
+
+/** The Likely files block for one agent's step, or "" without hints. */
+async function likelyFor(hints: FileHinter | undefined, query: string, signal: AbortSignal | undefined, context?: string): Promise<string> {
+  if (!hints) return "";
+  try {
+    return await hints.block(query, signal, context);
+  } catch {
+    return "";
+  }
+}
+
 function toOutcome(run: AgentRun, domain: Domain): ScoutOutcome {
   if (run.status !== "success") {
     return {
@@ -78,20 +109,36 @@ function toOutcome(run: AgentRun, domain: Domain): ScoutOutcome {
 
 /** Run the selected domain scouts concurrently and persist their findings. */
 export async function runScouts(request: ScoutRequest, run: ProcessRunner = spawnPiProcess): Promise<ScoutOutcome[]> {
-  const requests: AgentRequest[] = request.domains.map((domain) => ({
+  // Each scout gets the files most likely to answer its own instruction and focus.
+  const likely = await Promise.all(request.domains.map((domain) => likelyFor(request.hints, `${request.instruction}\n${domainSpec(domain).scoutFocus}`, request.signal, request.taskText)));
+  const extraTools = request.hints?.tools() ?? [];
+  const requests: AgentRequest[] = request.domains.map((domain, index) => ({
     taskId: request.taskId,
     domain,
     role: "scout",
     instruction: scoutInstruction(request, domain),
-    context: scoutContext(request, domain),
+    context: scoutContext(request, domain, likely[index]),
+    ...(extraTools.length > 0 ? { extraTools } : {}),
     ...profileFields(request.config, request.profile, domain, "scout"),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
     ...watchdogOptions(request.config.workflow),
   }));
-  const runs = await runParallel(requests, request.config.workflow.maxParallelScouts, run);
-  const outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
+  // Scouts think at a fixed level; a trivial one may move to the cheaper model.
+  const routes = await Promise.all(requests.map((entry) => routeFor(request.effort, entry.instruction, { ...(entry.model ? { model: entry.model } : {}), thinking: entry.thinking ?? "low" }, { thinkingFixed: true, context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) })));
+  const first = requests.map((entry, index) => (routes[index] ? { ...entry, ...routedFields(routes[index]!) } : entry));
+  const runs = await runParallel(first, request.config.workflow.maxParallelScouts, run);
+  let outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
+  // A routed scout that came back unusable runs again on its configured model.
+  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted ? index : -1)).filter((index) => index >= 0);
+  if (again.length > 0) {
+    const reruns = await runParallel(again.map((index) => requests[index]!), request.config.workflow.maxParallelScouts, run);
+    outcomes = outcomes.map((outcome, index) => {
+      const position = again.indexOf(index);
+      return position >= 0 ? toOutcome(reruns[position]!, reruns[position]!.domain) : outcome;
+    });
+  }
   saveScoutResults(request.taskDir, outcomes);
   return outcomes;
 }
@@ -152,9 +199,13 @@ export interface WorkerRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Likely files for the worker's step, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Lowers thinking (or the model) for a step the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
-function workerWorkflowContext(request: WorkerRequest): string {
+function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
   const spec = domainSpec(request.domain);
   const own = request.scoutOutcomes.filter(
     (outcome) => outcome.result.domain === request.domain && outcome.usable,
@@ -166,7 +217,8 @@ function workerWorkflowContext(request: WorkerRequest): string {
     own.length > 0
       ? `Scout findings for your domain:\n${summarizeOutcomes(own, 1500)}`
       : "No scout findings were collected for your domain; verify the repository yourself.",
-  ].join("\n\n");
+    likely,
+  ].filter(Boolean).join("\n\n");
 }
 
 /** Delegate one implementation step to a domain worker. */
@@ -176,28 +228,42 @@ export async function runWorker(
 ): Promise<WorkerOutcome> {
   const slices = readAgentKnowledge(request.dataRoots, request.domain);
   const selected = selectKnowledge(`${request.taskText} ${request.instruction}`, slices);
-  const agentRun = await runAgent(
-    {
-      taskId: request.taskId,
-      domain: request.domain,
-      role: "worker",
-      instruction: request.instruction,
-      context: {
-        task: request.taskText,
-        ...selected,
-        instructions: request.config.agents[request.domain].instructions,
-        workflowContext: workerWorkflowContext(request),
-      },
-      ...profileFields(request.config, request.profile, request.domain, "worker"),
-      cwd: request.cwd,
-      signal: request.signal,
-      onUpdate: request.onUpdate,
-      ...watchdogOptions(request.config.workflow),
-      ...request.agent,
+  const configured = profileFields(request.config, request.profile, request.domain, "worker");
+  const [likely, route] = await Promise.all([
+    likelyFor(request.hints, request.instruction, request.signal, request.taskText),
+    routeFor(request.effort, request.instruction, { ...(configured.model ? { model: configured.model } : {}), thinking: configured.thinking }, { context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) }),
+  ]);
+  const hintTools = request.hints?.tools() ?? [];
+  const extraTools = [...(request.agent?.extraTools ?? []), ...hintTools];
+  const base: AgentRequest = {
+    taskId: request.taskId,
+    domain: request.domain,
+    role: "worker",
+    instruction: request.instruction,
+    context: {
+      task: request.taskText,
+      ...selected,
+      instructions: request.config.agents[request.domain].instructions,
+      workflowContext: workerWorkflowContext(request, likely),
     },
-    run,
-  );
-  const result = parseWorkerResult(request.domain, agentRun.output);
+    ...configured,
+    cwd: request.cwd,
+    signal: request.signal,
+    onUpdate: request.onUpdate,
+    ...watchdogOptions(request.config.workflow),
+    ...request.agent,
+    ...(extraTools.length > 0 ? { extraTools } : {}),
+  };
+  let outcome = workerOutcome(request.domain, await runAgent(route ? { ...base, ...routedFields(route) } : base, run));
+  // A routed step that fell short runs again at the configured model and thinking.
+  if (route && fellShort(outcome.run, outcome.issues) && !request.signal?.aborted) {
+    outcome = workerOutcome(request.domain, await runAgent(base, run));
+  }
+  return outcome;
+}
+
+function workerOutcome(domain: Domain, agentRun: AgentRun): WorkerOutcome {
+  const result = parseWorkerResult(domain, agentRun.output);
   const issues =
     agentRun.status === "success"
       ? validateWorkerResult(result)

package/src/pi/commands.ts

@@ -19,7 +19,8 @@ import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
 import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type ApprovalChoice } from "../workflow/workflow.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
-import { openSettings } from "./settings-ui.ts";
+import { classifierSummary, openSettings } from "./settings-ui.ts";
+import { keyStatus } from "../classifier/instance.ts";
 import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
@@ -197,7 +198,8 @@ function showConfig(ctx: ExtensionCommandContext): void {
   const warnings = thinkingMismatches(config, modelLookup(ctx), ctx.model ? modelRef(ctx.model) : undefined);
   if (hasScoutThinking(readRawConfig())) warnings.push(`Scout: thinking is fixed at "${SCOUT_THINKING}"; the scout.thinking value in the file is ignored.`);
   const notes = warnings.length > 0 ? `\n\nWarnings:\n${warnings.map((line) => `- ${line}`).join("\n")}` : "";
-  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
+  const jev = `Classifier: ${classifierSummary(config, keyStatus)}`;
+  ctx.ui.notify(`${globalConfigPath()}\n${jev}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
 }
 
 /**

package/src/pi/events.ts

@@ -11,9 +11,19 @@ import { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity
 import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
 import { isSubagentProcess, visibleTools } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
-import { taskRequest, type Task } from "../schemas/task.ts";
+import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
+import { triageContext } from "../classifier/triage.ts";
+import { previousTaskNote } from "./fresh-context.ts";
+
+/** States in which the triage still helps the Master shape the task; once it is planned, the hints are noise. */
+const SHAPING_STATES: ReadonlySet<TaskState> = new Set(["created", "clarifying", "scouting", "synthesizing", "awaiting_approval"]);
+
+/** The Master's workflow context: the task's state, plus the classifier's triage while the task is being shaped. */
+export function masterWorkflowContext(task: Task): string {
+  return [describeTask(task), SHAPING_STATES.has(task.state) ? triageContext(task.triage) : ""].filter(Boolean).join("\n\n");
+}
 
 export function masterTaskContext(task: Task, comments: readonly PlanComment[] = [], auto = false): string {
   const open = pendingComments(comments);
@@ -83,9 +93,13 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   pi.on("before_agent_start", (event, ctx) => {
     const root = detectProjectRoot(ctx.cwd, configDir);
     const sessionId = ctx.sessionManager.getSessionId();
-    const task = isSubagentProcess() || isMinimized() ? undefined : activeTask(root, configDir, sessionId);
+    const hidden = isSubagentProcess() || isMinimized();
+    const task = hidden ? undefined : activeTask(root, configDir, sessionId);
     if (!task) {
-      delete event.systemPromptOptions.sections["bot-lobby"];
+      // After a task ended and cleared the context, a line on where its record is, in case the user refers back to it.
+      const previous = hidden ? undefined : previousTaskNote(ctx, configDir);
+      if (previous) event.systemPromptOptions.sections["bot-lobby"] = previous;
+      else delete event.systemPromptOptions.sections["bot-lobby"];
       return;
     }
     const slices = readAgentKnowledge(readDataRoots(root, configDir), "master");
@@ -96,7 +110,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,
-      workflowContext: describeTask(task),
+      workflowContext: masterWorkflowContext(task),
       instructions: loadConfig().master.instructions,
     });
   });