@a-t-h-i/bot-lobby 0.6.4 → 0.6.6

package/src/classifier/triage.ts

@@ -48,6 +48,15 @@ function sizeQuestion(subject: string) {
   return score(`How big is the change ${subject} asks for, judged by what it would take to build and verify in this repository?`, SIZE_LEVELS);
 }
 
+/** Whether one agent can just do it: the quick fix or the team. */
+function soloQuestion(subject: string) {
+  return noul(
+    `Could one engineer do ${subject} alone, right away — in one file or one area of the code — with no contract to agree between frontend and backend, no unfamiliar codebase to survey first, no risky change (security, data, payments, migrations) and no decision the user must make first?`,
+    "Yes: one person can just do it now, even if it is a rich piece of work in one place.",
+    "No: it needs a team — several areas, a survey of the codebase, a plan to agree, or review before it lands.",
+  );
+}
+
 export function triageRequest(input: TriageInput): SystemOneRequest {
   const questions: SystemOneRequest["questions"] = {
     size: sizeQuestion("`request`"),
@@ -62,6 +71,7 @@ export function triageRequest(input: TriageInput): SystemOneRequest {
       "No: a competent engineer could build it as written, deciding details from the codebase.",
     ),
     kind: choice("What kind of work does `request` ask for?", TRIAGE_KINDS),
+    solo: soloQuestion("`request`"),
   };
   for (const { domain, owns } of input.domains) {
     questions[`domain_${domain}`] = noul(`Does building \`request\` require changes in this area: ${owns}?`);
@@ -85,12 +95,14 @@ export async function triageTask(classifier: Classifier, input: TriageInput, sig
     if (probability !== undefined) domains[domain] = probability;
   }
   const kind = choiceOf(result.answers, "kind");
+  const solo = yesOf(result.answers, "solo");
   return {
     size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!,
     sizeConfidence: size.confidence,
     domains,
     research: yesOf(result.answers, "needs_research") ?? 0,
     ambiguous: yesOf(result.answers, "ambiguous") ?? 0,
+    ...(solo !== undefined ? { solo } : {}),
     ...(kind ? { kind: kind.choice, kindProbability: kind.probability } : {}),
     at: new Date().toISOString(),
   };
@@ -131,20 +143,25 @@ export async function triageWithContext(classifier: Classifier, scope: FileScope
   return files.length > 0 ? { ...triage, likelyFiles: files } : triage;
 }
 
-/** The size of a quick fix prompt, or undefined when the classifier is off or fails. */
-export async function quickFixSize(classifier: Classifier, prompt: string, signal?: AbortSignal): Promise<{ size: TriageSize; confidence: number } | undefined> {
+/**
+ * The size of a quick fix prompt, and how likely one engineer can do it alone,
+ * or undefined when the classifier is off or fails. A large prompt is held as
+ * a task unless it is still one engineer's work (a rich page in one file).
+ */
+export async function quickFixSize(classifier: Classifier, prompt: string, signal?: AbortSignal): Promise<{ size: TriageSize; confidence: number; solo?: number } | undefined> {
   if (!classifier.enabled("triage")) return undefined;
-  const largeAt = classifier.config.thresholds.quickFixLargeAt;
-  const result = await classifier.ask("triage", { state: { prompt: clip(prompt, 6000) }, questions: { size: sizeQuestion("`prompt`") } }, {
+  const { quickFixLargeAt: largeAt, quickFixAt } = classifier.config.thresholds;
+  const result = await classifier.ask("triage", { state: { prompt: clip(prompt, 6000) }, questions: { size: sizeQuestion("`prompt`"), solo: soloQuestion("`prompt`") } }, {
     ...(signal ? { signal } : {}),
     saved: (answers) => {
       const sized = scoreOf(answers, "size");
-      return sized && sized.level >= TRIAGE_SIZES.length - 1 && sized.confidence >= largeAt ? 1 : 0;
+      return sized && sized.level >= TRIAGE_SIZES.length - 1 && sized.confidence >= largeAt && (yesOf(answers, "solo") ?? 0) < quickFixAt ? 1 : 0;
     },
   });
   const size = scoreOf(result?.answers, "size");
   if (!size) return undefined;
-  return { size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!, confidence: size.confidence };
+  const solo = yesOf(result?.answers, "solo");
+  return { size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!, confidence: size.confidence, ...(solo !== undefined ? { solo } : {}) };
 }
 
 const HINT = 0.5;
@@ -155,7 +172,7 @@ export function suggestedPath(triage: TaskTriage): string {
   if (triage.ambiguous >= HINT) return "clarify first: the request as written probably misses a decision.";
   const smallish = (triage.size === "trivial" || triage.size === "small") && triage.sizeConfidence >= 0.6;
   const steps: string[] = [];
-  if (smallish && touched.length === 1) steps.push(`single-domain shortcut (${touched[0]}): skip the scout round and the proposal ceremony, state the short plan and delegate`);
+  if (smallish && touched.length === 1) steps.push(`fast track (${touched[0]}): no scouts, proposal or plan; delegate straight away`);
   else if (touched.length > 0) steps.push(`scout only ${touched.join(", ")}`);
   if (triage.research >= HINT) steps.push("summon the researcher for the outside facts");
   return steps.length > 0 ? `${steps.join("; ")}.` : "no strong signal; decide from the request.";

package/src/index.ts

@@ -2,6 +2,7 @@ import { CONFIG_DIR_NAME, type ExtensionAPI } from "@earendil-works/pi-coding-ag
 import { registerCommands } from "./pi/commands.ts";
 import { registerLifecycle } from "./pi/events.ts";
 import { registerOrchestrateTool } from "./pi/tools.ts";
+import { registerRouteTool } from "./pi/route.ts";
 import { onTransition } from "./state/task-state.ts";
 import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
@@ -20,12 +21,14 @@ export default function (pi: ExtensionAPI): void {
   // Before the lifecycle, so a task that ended while the oracle was idle is closed before it builds the next turn's prompt.
   registerFreshContext(pi, CONFIG_DIR_NAME);
   registerLifecycle(pi, CONFIG_DIR_NAME);
-  // After the lifecycle, so the lobby opens over a task the widget state already knows.
+  // After the lifecycle, so the lobby opens over a task the status already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
   registerOwner(pi, CONFIG_DIR_NAME);
   onTransition((task) => pingTransition(task));
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
+  // A new request one agent can do alone: the oracle confirms, and the lobby hands it to the quick-fix agent.
+  registerRouteTool(pi, CONFIG_DIR_NAME);
   // The questionnaire the oracle (and pi without a task) asks the user with; no other extension is needed for it.
   registerAskTool(pi);
   // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).

package/src/lobby/feed.ts

@@ -2,7 +2,7 @@
  * What the lobby narrates: an activity log of plain-words tool steps from the
  * Master and every subagent, a single place for thoughts, and the conversation
  * with the Master stripped of tool rows and thinking. Bounded ring buffers in
- * one module-level store (like the zen widget state), so every event source can
+ * one module-level store (like the task state in ui.ts), so every event source can
  * write without a reference to the lobby, and the lobby repaints on `version`.
  */
 import type { AgentRun } from "../schemas/findings.ts";
@@ -284,8 +284,13 @@ export function chatText(role: "user" | "assistant", text: string): Array<{ role
   const kickoff = /^A bot-lobby task is active: (\S+)\nTitle: (.*)/.exec(body);
   if (kickoff) {
     const request = /\nRequest: ([\s\S]*?)(?:\nState: |$)/.exec(body)?.[1]?.trim();
-    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request ? [{ role: "you" as const, text: request }] : [])];
+    // A request the oracle routed to the team is already in the conversation, under the routing note.
+    const shown = /\nRouted: /.test(body);
+    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request && !shown ? [{ role: "you" as const, text: request }] : [])];
   }
+  // A new request the classifier read as a quick fix, before the oracle confirms where it goes.
+  const routing = /^bot-lobby: a new request, not a task yet\.\nRequest: ([\s\S]*?)\nRead: /.exec(body);
+  if (routing) return [{ role: "you", text: routing[1]!.trim() }, { role: "note", text: "reads as a quick fix · the oracle confirms where it goes" }];
   const comment = /^The user left (?:a comment|\d+ comments) on (the approved plan|the proposal) of (\S+) from the lobby:/.exec(body);
   if (comment) return [{ role: "note", text: `your comment on ${comment[1]} went to the oracle` }];
   return [{ role: "you", text: body }];

package/src/lobby/keys.ts

@@ -17,7 +17,6 @@ export const LOBBY_ACTIONS = {
   toggleAuto: { key: "alt+g", help: "auto mode: the oracle drives the task to completion without asking" },
   nextTab: { key: "tab", help: "next tab" },
   prevTab: { key: "shift+tab", help: "previous tab" },
-  toggleScene: { key: "alt+z", help: "show or hide the oracle and agent animations" },
   toggleConversation: { key: "alt+c", help: "show or hide the conversation" },
   toggleActivity: { key: "alt+a", help: "show or hide the activity log" },
   toggleThinking: { key: "alt+k", help: "show or hide thinking" },

package/src/lobby/quickfix.ts

@@ -54,6 +54,19 @@ export interface QuickFixJob {
   routedFrom?: string;
   /** Files it changed with `edit`/`write`, as shown (relative to the project); the change ledger lets a running task's QA gate tell them from its own. */
   files?: string[];
+  /** Runs on this profile instead of the quick-fix settings: a quick feature the oracle routed here gets its builder's model, thinking and time. */
+  profile?: QuickFixProfile;
+  /** The oracle sent it here from a request typed to the lobby. */
+  routed?: boolean;
+}
+
+/** How a job enters the queue besides its prompt. */
+export interface SubmitOptions {
+  /** Skip the classifier's "looks like a task" hold (the oracle already routed it here). */
+  force?: boolean;
+  profile?: QuickFixProfile;
+  /** Shown with the job: where it came from. */
+  note?: string;
 }
 
 export interface QuickFixProfile {
@@ -118,10 +131,21 @@ export class QuickFixQueue {
   }
 
   /** Queue a quick fix; it starts at once when nothing else is running. */
-  submit(prompt: string, now = Date.now()): QuickFixJob {
+  submit(prompt: string, now = Date.now(), options: SubmitOptions = {}): QuickFixJob {
     const text = prompt.trim();
     if (!text) throw new Error("a quick fix needs a prompt");
-    const job: QuickFixJob = { id: `QF-${++this.counter}`, prompt: text, status: "queued", createdAt: now, steps: [], tools: 0, turns: 0 };
+    const job: QuickFixJob = {
+      id: `QF-${++this.counter}`,
+      prompt: text,
+      status: "queued",
+      createdAt: now,
+      steps: [],
+      tools: 0,
+      turns: 0,
+      ...(options.force ? { force: true, routed: true } : {}),
+      ...(options.profile ? { profile: options.profile } : {}),
+      ...(options.note ? { note: options.note } : {}),
+    };
     this.jobs = [...this.jobs, job].filter((entry, index, all) => isActive(entry) || index >= all.length - MAX_JOBS);
     this.changed();
     this.pump();
@@ -203,7 +227,7 @@ export class QuickFixQueue {
   }
 
   private async run(job: QuickFixJob): Promise<void> {
-    const profile = this.deps.profile();
+    const profile = job.profile ?? this.deps.profile();
     const controller = new AbortController();
     this.controllers.set(job.id, controller);
     job.status = "running";
@@ -287,6 +311,8 @@ export class QuickFixQueue {
     try {
       const sized = await quickFixSize(jev, job.prompt, signal);
       if (!sized || sized.size !== "large" || sized.confidence < jev.config.thresholds.quickFixLargeAt) return undefined;
+      // Large but still one engineer's work (a rich page in one file): it runs.
+      if ((sized.solo ?? 0) >= jev.config.thresholds.quickFixAt) return undefined;
       return `looks like a task (large, ${sized.confidence.toFixed(2)})`;
     } catch {
       return undefined;

package/src/lobby/runtime.ts

@@ -20,13 +20,14 @@ import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listA
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.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";
+import { applyStatus, currentZenTask, isMinimized, onMinimizeChange, onRunUpdates, setMinimized, taskSnapshot } from "../pi/ui.ts";
 import { shortTitle } from "../text.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { modelRef, resolveLobbyProfile, resolvePanelProfile } from "../pi/model-support.ts";
 import { modelLookup } from "../pi/tools.ts";
-import { startPlannedTask, startTask } from "../pi/start-task.ts";
+import { startPlannedTask } from "../pi/start-task.ts";
+import { pendingRequest, setQuickFixHandoff, startRequest } from "../pi/route.ts";
+import type { Domain } from "../schemas/agent.ts";
 import type { LobbyAgentKind, LobbyPanel, PanelMember } from "../schemas/configuration.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike, type ChatEntry } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
@@ -41,7 +42,6 @@ import { LobbyView, type LiveSession, type LobbyHost, type SwitchTarget, type Ta
 import { lobbyTheme } from "./theme.ts";
 import { deliverComments, onOwnerEvent, setAuto } from "../pi/owner.ts";
 import { openEntrySettings, openSettings } from "../pi/settings-ui.ts";
-import { budgetClock } from "../state/budget.ts";
 
 export const ANCHOR_KEY = "bot-lobby-anchor";
 export { deliverComments };
@@ -57,7 +57,6 @@ interface Runtime {
   visible: boolean;
   /** Stepped aside while pi shows a dialog. */
   asideForPrompt: boolean;
-  scene: ZenScene;
   quickfix: QuickFixQueue;
   planner?: PlanningSession;
   issues: IssuesState;
@@ -149,9 +148,10 @@ function toOracle(state: Runtime, text: string): string | undefined {
     state.pi.sendUserMessage(text, { expandPromptTemplates: true, ...(busy ? { deliverAs: "followUp" as const } : {}) });
     return `sent ${text.split(/\s+/)[0]} to pi (built-in commands need the lobby hidden: alt+l)`;
   }
-  if (!currentZenTask()) {
-    startTask(state.pi, state.ctx, state.configDir, text).catch((error: Error) => failed(state, "could not start the task", error));
-    return "starting a task — the oracle takes it from here";
+  // While the oracle decides where a request goes, what the user types joins that conversation.
+  if (!currentZenTask() && !pendingRequest()) {
+    startRequest(state.pi, state.ctx, state.configDir, text).catch((error: Error) => failed(state, "could not start the task", error));
+    return "reading your request — a quick fix or a task, the oracle takes it from here";
   }
   state.pi.sendUserMessage(text, busy ? { deliverAs: "steer" } : undefined);
   return undefined;
@@ -423,13 +423,6 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   return `deleted ${taskId} for good`;
 }
 
-/** A task's status box without animations, for a session other than this window's. */
-function taskScene(state: Runtime, task: Task, width: number, height: number): string[] {
-  const now = Date.now();
-  const time = budgetClock(state.root, state.configDir, task.id, now);
-  return panelLines(task, persistedRuns(task), now, false, { width, rows: Math.floor(height / 0.75), still: true, theme: state.ctx.ui.theme, ...(time ? { time } : {}) });
-}
-
 function seatProfile(state: Runtime, member: PanelMember) {
   return resolvePanelProfile(loadConfig(), member, {
     lookup: modelLookup(state.ctx),
@@ -515,15 +508,9 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     theme: () => lobbyTheme(state.ctx.ui.theme),
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
-      const snapshot = zenSnapshot();
+      const snapshot = taskSnapshot();
       return { ...(snapshot.task ? { task: snapshot.task } : {}), runs: snapshot.runs };
     },
-    // The scene's height budget is 3/4 of the rows it is given.
-    scene: (width, height, animated) => state.scene.lines(width, Math.floor(height / 0.75), state.ctx.ui.theme, Date.now(), !animated),
-    advanceScene: (now) => {
-      state.scene.advance(now);
-      return state.scene.delay(now);
-    },
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
     tasks: () => peekTasks(state.root, state.configDir),
@@ -574,7 +561,6 @@ function host(state: Runtime, tui: TUI): LobbyHost {
     sessionChat: (sessionId) => chats.chat(sessionId),
     hasOlderChat: (sessionId) => chats.hasOlder(sessionId),
     chatHistory: (sessionId) => chatHistory(state, sessionId),
-    taskScene: (task, width, height) => taskScene(state, task, width, height),
     requestRender: () => tui.requestRender(),
   };
 }
@@ -706,17 +692,35 @@ function shutdown(): void {
   const state = runtime;
   if (!state) return;
   runtime = undefined;
+  setQuickFixHandoff(undefined);
   setMouse(state, false);
   state.unsubscribeFeed?.();
   state.quickfix.cancelAll();
   state.planner?.cancel();
   state.view?.dispose();
   state.handle?.hide();
-  setWidgetSuppressor(() => false);
   onRunUpdates(undefined);
   onMinimizeChange(undefined);
 }
 
+/**
+ * The oracle routed a request to the quick-fix agent: queue it (no "looks like
+ * a task" hold, the oracle already decided), on its builder's settings when it
+ * is a quick feature, and show it on the Quick fix tab.
+ */
+function handToQuickFix(state: Runtime, request: string, builder: Domain | undefined, reason: string): string {
+  const quick = lobbyProfile(state, "quickfix");
+  const profile = builder ? { ...seatProfile(state, builder), instructions: quick.instructions } : undefined;
+  const job = state.quickfix.submit(request, Date.now(), {
+    force: true,
+    ...(profile ? { profile } : {}),
+    note: `The oracle sent your request here: ${reason.replace(/[.\s]+$/, "")}.${builder ? ` A quick feature: it runs on ${builder === "designer" ? "DESIGN" : "DEV"}'s model, thinking and time limit.` : ""}`,
+  });
+  showLobby("quickfix");
+  state.view?.showQuickFix(job.id);
+  return job.id;
+}
+
 /** Create the session's lobby runtime (interactive master sessions only). */
 export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string): void {
   shutdown();
@@ -733,7 +737,6 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     asking: false,
     mouse: false,
     inSettings: false,
-    scene: new ZenScene(),
     quickfix: undefined as unknown as QuickFixQueue,
     issues: new IssuesState(execCommand, ctx.cwd, rerender),
   };
@@ -754,11 +757,11 @@ export function initLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: st
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
   });
   runtime = state;
+  setQuickFixHandoff((request, builder, reason) => (runtime === state ? handToQuickFix(state, request, builder, reason) : undefined));
   lobbyFeed.clear();
   // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.
   lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY));
   state.unsubscribeFeed = lobbyFeed.onChange(rerender);
-  setWidgetSuppressor(() => runtime?.visible === true);
   onRunUpdates((runs) => lobbyFeed.runs(runs));
   onMinimizeChange((value) => {
     if (value) hideLobby();

package/src/lobby/tabs/home.ts

@@ -1,9 +1,8 @@
 /**
- * The Lobby tab: the zen scene of this session's task on top (the oracle
- * and agent animations, or just their status when animations are off), then the
+ * The Lobby tab: the status of this session's task on top, then the
  * conversation with the oracle (text only, no tool rows, no thinking), the
  * activity log of plain-words steps from every agent, and the one place where
- * thoughts show up. Pure: the scene arrives as a callback, the clock as `now`.
+ * thoughts show up. Pure: the clock arrives as `now`.
  */
 import { textWidth } from "../../width.ts";
 import type { Task } from "../../schemas/task.ts";
@@ -18,8 +17,6 @@ export type HomePane = (typeof HOME_PANES)[number];
 
 export interface HomeInput {
   task?: Task;
-  /** Draws the zen scene into at most `height` lines, animated or still; absent when no task is active. */
-  scene?: (width: number, height: number, animated: boolean) => string[];
   chat: readonly ChatEntry[];
   /** The oracle's reply while it streams. */
   liveReply?: string;
@@ -48,8 +45,6 @@ export interface HomeInput {
   keys?: Record<LobbyPanel, string>;
   /** Another session is shown: its name titles the conversation. */
   title?: string;
-  /** The scene is another session's still status (no animations to toggle). */
-  stillScene?: boolean;
   /** What the empty conversation says instead of the default (a session starting, say). */
   emptyNote?: string;
   /** What the empty activity log says instead of "No activity yet.". */
@@ -60,11 +55,6 @@ export interface HomeInput {
 
 /** Wide terminals put the conversation and the activity log side by side. */
 export const HOME_COLUMNS_MIN = 100;
-/** Most lines the scene may take, and its share of the body; the still status needs far fewer. */
-const SCENE_SHARE = 0.45;
-const MAX_SCENE = 36;
-const MAX_STILL = 10;
-
 const SOURCE_COLORS: Record<string, LobbyColor> = {
   MASTER: "accent",
   DEV: "success",
@@ -490,31 +480,6 @@ function thinkingContent(input: HomeInput, thoughts: readonly ThoughtEntry[], wi
   return whole([paint(theme, "dim", input.query ? `No thought matches "${input.query}".` : "Thoughts from the oracle and every agent appear here, and only here.")]);
 }
 
-/**
- * The scene: with animations off (the `animations` panel, off by default)
- * only the task's status box, what the agents are doing and the checklist;
- * with them on, the animated oracle and agents too. Its first line names the
- * key that toggles the animations.
- */
-function sceneLines(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
-  if (!input.task || !input.scene) return [];
-  const animated = input.panels.animations && !input.stillScene;
-  const budget = Math.min(animated ? MAX_SCENE : MAX_STILL, Math.floor(height * SCENE_SHARE));
-  if (budget < (animated ? 6 : 4)) return [];
-  const lines = input.scene(width, budget, animated).slice(0, budget);
-  const note = input.keys && !input.stillScene ? `${input.keys.animations} ${animated ? "hides" : "shows"} animations` : undefined;
-  return keyNote(lines, width, note, theme);
-}
-
-/** `note` at the right end of the first line, dimmed, when it fits beside what is there. */
-function keyNote(lines: readonly string[], width: number, note: string | undefined, theme?: LobbyTheme): string[] {
-  const first = lines[0];
-  if (!note || first === undefined) return [...lines];
-  const gap = width - textWidth(first) - textWidth(note) - 1;
-  if (gap < 2) return [...lines];
-  return [`${first}${" ".repeat(gap)}${paint(theme, "dim", note)}`, ...lines.slice(1)];
-}
-
 function hiddenHint(input: HomeInput, width: number, height: number, theme?: LobbyTheme): string[] {
   const keys = input.keys;
   const text = keys
@@ -536,12 +501,11 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   if (height <= 0) return [];
   const { panels } = input;
   const feed = filterFeed(input);
-  const scene = sceneLines(input, width, height, theme);
-  const rest = height - scene.length;
+  const rest = height;
   const showMain = panels.conversation || panels.activity;
   const thinkHeight = !panels.thinking ? 0 : !showMain ? rest : rest >= 18 ? Math.max(5, Math.floor(rest * 0.25)) : rest >= 10 ? 4 : 0;
   const main = rest - thinkHeight;
-  if (!showMain && !panels.thinking) return fill([...scene, ...hiddenHint(input, width, rest, theme)], height, width);
+  if (!showMain && !panels.thinking) return fill(hiddenHint(input, width, rest, theme), height, width);
   const matches = (count: number) => `${count} match${count === 1 ? "" : "es"}`;
   /**
    * One scrollable pane: only the lines it shows are drawn — its newest, or
@@ -563,7 +527,7 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   const thought = currentThought(feed.thoughts);
   const thinkingNote = thought ? `${thought.source} · ${thought.live ? "thinking" : since(input.now - thought.at)}` : input.keys?.thinking;
   const thinkingBox = pane("thinking", "Thinking", thinkingNote, (inner, need, anchor) => thinkingContent(input, feed.thoughts, inner, need, anchor, theme));
-  const top = scene.length;
+  const top = 0;
   let body: string[] = [];
   if (main > 0 && panels.conversation && panels.activity) {
     if (width >= HOME_COLUMNS_MIN) {
@@ -576,5 +540,5 @@ export function renderHome(input: HomeInput, width: number, height: number, them
   } else if (main > 0 && panels.conversation) body = chatBox(top, 0, width, main);
   else if (main > 0 && panels.activity) body = activityBox(top, 0, width, main);
   const think = thinkHeight >= 3 ? thinkingBox(top + main, 0, width, thinkHeight) : [];
-  return fill([...scene, ...fill(body, main), ...think], height, width);
+  return fill([...fill(body, main), ...think], height, width);
 }

package/src/lobby/tabs/quickfix.ts

@@ -65,7 +65,7 @@ export function jobDetailLines(job: QuickFixJob, width: number, tick: number, no
   const asked = theme?.markdown ? markdownLines(job.prompt, width, theme, true, "you") : wrap(bold(theme, job.prompt), width);
   const lines = [paint(theme, "dim", job.id), facts.join(paint(theme, "dim", " · ")), "", ...asked];
   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));
+  if (job.note) lines.push("", ...wrap(paint(theme, job.status === "held" ? "warning" : job.routed ? "muted" : "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…` : job.status === "held" ? "Not started." : "No tool calls."));
   for (const step of job.steps) {

package/src/lobby/tabs/tasks.ts

@@ -7,7 +7,7 @@
 import { TERMINAL_STATES, taskRequest, type Task } from "../../schemas/task.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
 import type { PlanComment } from "../../state/comments.ts";
-import { planChecklist } from "../../pi/zen.ts";
+import { planChecklist } from "../../pi/plan-checklist.ts";
 import { persistedRuns } from "../../pi/ui.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
@@ -268,7 +268,8 @@ export function taskDetailLines(task: Task, comments: readonly PlanComment[], se
     finished ? paint(theme, "muted", `${task.state === "abandoned" ? "dropped" : "done"} ${since(now - Date.parse(task.updatedAt))}`) : "",
   ].filter(Boolean);
   lines.push(...wrapHanging("  ", facts.join(dot), width));
-  lines.push(...wrapHanging("  ", paint(theme, "dim", [task.id, task.domains.length > 0 ? task.domains.join(", ") : ""].filter(Boolean).join(" · ")), width));
+  const track = task.track ? (task.track.path === "fast" ? `fast track (${task.track.size})` : `full workflow (${task.track.size})`) : "";
+  lines.push(...wrapHanging("  ", paint(theme, "dim", [task.id, track, task.domains.length > 0 ? task.domains.join(", ") : ""].filter(Boolean).join(" · ")), width));
   const steps = task.plan ? planChecklist(task.plan, persistedRuns(task)) : [];
   const done = steps.filter((step) => step.status === "done").length;
   if (steps.length > 0) {

package/src/lobby/view.ts

@@ -54,8 +54,8 @@ const PROMPT_FIRST: ReadonlySet<TabId> = new Set(["lobby", "plan", "quickfix"]);
 export type LobbyMode = "type" | "browse";
 
 /** What each pane toggle is called in notices and help. */
-const PANEL_NAMES: Record<LobbyPanel, string> = { animations: "oracle and agent animations", conversation: "conversation", activity: "activity log", thinking: "thinking" };
-const PANEL_ACTIONS: Record<LobbyPanel, LobbyAction> = { animations: "toggleScene", conversation: "toggleConversation", activity: "toggleActivity", thinking: "toggleThinking" };
+const PANEL_NAMES: Record<LobbyPanel, string> = { conversation: "conversation", activity: "activity log", thinking: "thinking" };
+const PANEL_ACTIONS: Record<LobbyPanel, LobbyAction> = { conversation: "toggleConversation", activity: "toggleActivity", thinking: "toggleThinking" };
 
 /**
  * Which session the Lobby tab shows and talks to: this window, one it started
@@ -125,12 +125,8 @@ export interface LobbyHost {
   rows(): number;
   theme(): LobbyTheme;
   sessionId(): string | undefined;
-  /** This session's active task and its runs, as the zen widget sees them. */
+  /** This session's active task and its runs, as the lobby reads them. */
   zen(): { task?: Task; runs: readonly AgentRun[] };
-  /** Draw the zen scene into at most `height` lines: animated, or only the task's status when `animated` is false. */
-  scene(width: number, height: number, animated: boolean): string[];
-  /** Advance the scene's clock; returns the delay it wants until the next step. */
-  advanceScene(now: number): number;
   feed: LobbyFeed;
   masterBusy(): boolean;
   tasks(): Task[];
@@ -199,14 +195,12 @@ export interface LobbyHost {
   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;
   requestRender(): void;
   now?(): number;
 }
 
-/** Live work speeds the clock up so spinners and the scene move. */
+/** Live work speeds the clock up so spinners move. */
 export const LIVE_MS = 250;
 export const IDLE_MS = 1000;
 /** How often task and metrics data is reread from disk while the lobby is open. */
@@ -424,16 +418,13 @@ export class LobbyView implements Component, Focusable {
       || Boolean(zen.task && !zen.task.paused && !TERMINAL_STATES.includes(zen.task.state));
   }
 
-  /** One clock step: advance the scene, reread data when due, repaint. */
+  /** One clock step: reread data when due, repaint. */
   private step(): void {
     if (!this.running) return;
-    const now = this.now();
     this.tick += 1;
-    let delay = this.isLive() ? LIVE_MS : IDLE_MS;
-    if (this.tab === "lobby" && this.panels.animations && this.host.zen().task) delay = Math.min(delay, this.host.advanceScene(now));
     this.refreshData(false);
     this.host.requestRender();
-    this.schedule(delay);
+    this.schedule(this.isLive() ? LIVE_MS : IDLE_MS);
   }
 
   /** Reread tasks, plans, comments and metrics from disk (throttled unless forced). */
@@ -471,6 +462,15 @@ export class LobbyView implements Component, Focusable {
     return visibleTabs(this.issuesOn);
   }
 
+  /** Open the Quick fix tab on a job the oracle routed there, with a line saying so. */
+  showQuickFix(id: string): void {
+    this.setTab("quickfix");
+    delete this.queries.quickfix;
+    this.fixSelected = Math.max(0, this.fixJobs().findIndex((job) => job.id === id));
+    this.fixDetailOffset = 0;
+    this.say(`${id} — the oracle sent your request to the quick-fix agent`);
+  }
+
   setTab(tab: TabId): void {
     if (tab === this.tab) return;
     if (!this.tabs().includes(tab)) return this.say(`the ${TAB_LABELS[tab]} tab is off — set lobby.${tab} to true in the config to bring it back`, "warning");
@@ -666,8 +666,6 @@ export class LobbyView implements Component, Focusable {
         return this.cycleTab(1);
       case "prevTab":
         return this.cycleTab(-1);
-      case "toggleScene":
-        return this.togglePanel("animations");
       case "toggleConversation":
         return this.togglePanel("conversation");
       case "toggleActivity":
@@ -2286,7 +2284,7 @@ export class LobbyView implements Component, Focusable {
     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) } : {}),
+      ...(zen.task ? { task: zen.task } : {}),
       chat: talk.chat,
       ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       ...(feed.reply ? { liveReply: feed.reply } : {}),
@@ -2304,7 +2302,6 @@ export class LobbyView implements Component, Focusable {
       panels: this.panels,
       ...(query ? { query } : {}),
       keys: {
-        animations: keyLabel(this.keys.toggleScene),
         conversation: keyLabel(this.keys.toggleConversation),
         activity: keyLabel(this.keys.toggleActivity),
         thinking: keyLabel(this.keys.toggleThinking),
@@ -2314,8 +2311,7 @@ export class LobbyView implements Component, Focusable {
 
   /**
    * Another session on the Lobby tab: a background session's live feed, or an
-   * other terminal's conversation read from its session file; the task's
-   * status sits on top without animations.
+   * other terminal's conversation read from its session file.
    */
   private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
     const session = this.viewedSession();
@@ -2323,7 +2319,7 @@ export class LobbyView implements Component, Focusable {
     const task = entry.task;
     const query = this.query();
     const common = {
-      ...(task ? { task, scene: (w: number, h: number) => this.host.taskScene(task, w, h), stillScene: true } : {}),
+      ...(task ? { task } : {}),
       others: 0,
       pending: 0,
       offsets: this.homeOffsets,
@@ -2336,7 +2332,6 @@ export class LobbyView implements Component, Focusable {
       ...(query ? { query } : {}),
       title: entry.name,
       keys: {
-        animations: keyLabel(this.keys.toggleScene),
         conversation: keyLabel(this.keys.toggleConversation),
         activity: keyLabel(this.keys.toggleActivity),
         thinking: keyLabel(this.keys.toggleThinking),

package/src/master/decisions.ts

@@ -2,12 +2,20 @@ import type { Decision, Task, Verdict } from "../schemas/task.ts";
 import type { Domain } from "../schemas/agent.ts";
 import type { ScoutOutcome } from "./master.ts";
 import { detectGaps, domainsInvolved } from "./synthesis.ts";
+import { builtSomething, onFastTrack, qaRequired, qaTookPart } from "../workflow/track.ts";
 
-/** §19: everything the engine requires before completion may be declared. */
+/**
+ * §19: everything the engine requires before completion may be declared. The
+ * fast track asks for a finished worker step instead of a QA pass, and for
+ * QA's part only when the change needs tests.
+ */
 export function completionBlockers(task: Task, pendingCount: number): string[] {
   const blockers: string[] = [];
   if (!task.plan) blockers.push("no approved plan is recorded");
-  if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
+  if (onFastTrack(task)) {
+    if (!builtSomething(task)) blockers.push("no worker step has finished yet");
+    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (give qa the tests as the last step, or run the QA gate)");
+  } else if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
   if (pendingCount > 0) blockers.push(`${pendingCount} unresolved approval request(s)`);
   if (task.blockers.length > 0) blockers.push(`${task.blockers.length} unresolved blocker(s)`);
   return blockers;