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

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

@@ -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

@@ -471,6 +471,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");

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;

package/src/pi/commands.ts

@@ -21,19 +21,22 @@ import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAs
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
 import { classifierSummary, openSettings } from "./settings-ui.ts";
 import { keyStatus } from "../classifier/instance.ts";
-import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
+import { kickoff, startPlannedTask } from "./start-task.ts";
+import { startRequest } from "./route.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
 import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
 import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startClock } from "../state/budget.ts";
+import { qaStillDue } from "../workflow/track.ts";
 
 const HELP = [
   "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
-  "/bot-lobby <request>        Start a task through the workflow",
-  "/bot-lobby --task [--auto] <request>   Start a task even when the request begins with a subcommand word",
+  "/bot-lobby <request>        Start a request: a quick fix when one agent can do it alone (the oracle confirms), else a task",
+  "/bot-lobby --task [--auto] <request>   Always a task (also when the request begins with a subcommand word)",
   "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
+  "/bot-lobby --fast|--full <request>   Start a task on the fast track (straight to the agents it needs) or the full workflow, whatever it reads as",
   "/bot-lobby budget [90m|off]  Show or set this session's task time budget",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
@@ -60,8 +63,8 @@ function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
 }
 
-/** A task start's leading flags: `--task` (always a task), `--auto`, `--budget <time>` (or `--budget=<time>`). */
-const START_FLAG = /^--(task|auto)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+/** A task start's leading flags: `--task` (always a task), `--auto`, `--fast`, `--full`, `--budget <time>` (or `--budget=<time>`). */
+const START_FLAG = /^--(task|auto|fast|full)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
 
 export interface ParsedCommand {
   sub: string | undefined;
@@ -72,6 +75,10 @@ export interface ParsedCommand {
   budget?: number;
   /** `--budget` with something that is not a time. */
   budgetError?: string;
+  /** `--fast` or `--full`: the task's path, whatever its request reads as. */
+  track?: "fast" | "full";
+  /** `--task`: a task, never routed to the quick-fix agent. */
+  task?: boolean;
 }
 
 export function parseCommand(args: string): ParsedCommand {
@@ -79,10 +86,12 @@ export function parseCommand(args: string): ParsedCommand {
   // Leading flags start a task: what follows is its request, even when it begins with a subcommand word
   // (a background session started from the lobby sends `--task [--auto] <request>`).
   let flagged = false;
-  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError"> = {};
+  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError" | "track" | "task"> = {};
   for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
     flagged = true;
     if (match[1] === "auto") extras.auto = true;
+    else if (match[1] === "task") extras.task = true;
+    else if (match[1] === "fast" || match[1] === "full") extras.track = match[1];
     else if (match[2] !== undefined) {
       const minutes = parseMinutes(match[2]);
       if (minutes) extras.budget = minutes;
@@ -119,7 +128,7 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
   ].filter(Boolean).join("\n");
   const footer = knowledge ? `\n${knowledge}` : "";
   const budget = task ? readBudget(root, configDir, task.id) : undefined;
-  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : "";
+  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : "";
   ctx.ui.notify(task ? `${describeTask(task)}${time}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
@@ -243,7 +252,7 @@ function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: s
   if (!task) return ctx.ui.notify("bot-lobby: no active task in this session — a time budget applies to a task (start one with /bot-lobby --budget 90m <request>)", "warning");
   if (!value) {
     const budget = readBudget(root, configDir, task.id);
-    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
+    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
   }
   const minutes = /^off$/i.test(value) ? 0 : parseMinutes(value);
   if (minutes === undefined) return ctx.ui.notify(`bot-lobby: "${value}" is not a time budget (try 90m, 1h or 1h30m)`, "warning");
@@ -251,7 +260,7 @@ function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: s
   // Set while the oracle works: its clock runs from now, not from its next turn.
   if (budget && !ctx.isIdle()) startClock(root, configDir, task.id);
   applyStatus(ctx, root, configDir);
-  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
+  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
 }
 
 function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
@@ -315,14 +324,16 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto, budget, budgetError } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, budget, budgetError, track, task } = parseCommand(args ?? "");
       if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
         if (!restText) {
           if (!showLobby()) ctx.ui.notify(HELP, "info");
           return;
         }
-        if (await startTask(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}) })) autoOpenLobby();
+        // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
+        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}) });
+        if (started === "task") autoOpenLobby();
         return;
       }
       switch (sub) {

package/src/pi/events.ts

@@ -15,6 +15,7 @@ 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 { qaStillDue } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
 import { budgetLine, budgetState, pauseClocks, readBudget, resumeClocks, startClock, stopClocks } from "../state/budget.ts";
 
@@ -33,7 +34,7 @@ export function masterWorkflowContext(task: Task, time = ""): string {
 export function budgetContext(root: string, configDir: string, task: Task): string {
   const budget = readBudget(root, configDir, task.id);
   if (!budget) return "";
-  const state = budgetState(task.id, budget, task.qaVerdict === "pass");
+  const state = budgetState(task.id, budget, !qaStillDue(task));
   const running = budget.allotments.filter((entry) => !entry.endedAt).map((entry) => `${entry.who} (${entry.minutes}m)`);
   return [
     budgetLine(budget, state),

package/src/pi/route.ts

@@ -0,0 +1,180 @@
+/**
+ * Where a new request goes before any task exists. The classifier (Jev, or
+ * the rules while it is off) reads whether one agent can do it alone, right
+ * away. When it can, the oracle confirms with `route_request`: the lobby hands
+ * the request to the quick-fix agent and shows the Quick fix tab. Otherwise,
+ * or when the oracle says it needs the team, the task starts as before.
+ *
+ * Nothing is routed without the lobby (it runs quick fixes), when routing is
+ * off (`workflow.routeQuickFixes`), or for a request the user already placed
+ * (`--task`, `--fast`, `--full`) or a planned task.
+ */
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import type { Domain } from "../schemas/agent.ts";
+import type { TaskTriage } from "../schemas/task.ts";
+import { chooseRoute, type RequestRoute } from "../workflow/track.ts";
+import { triageFor } from "../classifier/instance.ts";
+import { ownedTask } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { lobbyFeed } from "../lobby/feed.ts";
+import { startTask, type StartOptions } from "./start-task.ts";
+import { isQuiet, isSubagentProcess } from "./quiet.ts";
+
+export const ROUTE_TOOL = "route_request";
+
+/**
+ * Hands a request to the lobby's quick-fix agent and shows the Quick fix tab;
+ * the job's id, or undefined without a lobby. `builder` is set for a quick
+ * feature: it runs on that domain's model, thinking and time limit.
+ */
+export type QuickFixHandoff = (request: string, builder: Domain | undefined, reason: string) => string | undefined;
+
+let handoff: QuickFixHandoff | undefined;
+
+/** The lobby registers its quick-fix hand-off while it runs. */
+export function setQuickFixHandoff(next: QuickFixHandoff | undefined): void {
+  handoff = next;
+}
+
+interface Pending {
+  request: string;
+  options: StartOptions;
+  route: RequestRoute;
+  at: number;
+}
+
+let pending: Pending | undefined;
+
+/** A request the oracle has not routed in this long is forgotten: the next one starts afresh. */
+const STALE_MS = 30 * 60_000;
+
+/** The request waiting for the oracle to route it, if any. */
+export function pendingRequest(now = Date.now()): { request: string; route: RequestRoute } | undefined {
+  if (pending && now - pending.at >= STALE_MS) pending = undefined;
+  return pending ? { request: pending.request, route: pending.route } : undefined;
+}
+
+/** A quick feature (bigger than a small change, but self-contained) runs with its builder's settings; a quick fix with the quick-fix agent's. */
+function builderFor(route: RequestRoute): Domain | undefined {
+  return route.size === "medium" || route.size === "large" ? route.builder : undefined;
+}
+
+/** What the oracle is asked: one step, from the request alone. */
+export function routeMessage(request: string, route: RequestRoute): string {
+  return [
+    "bot-lobby: a new request, not a task yet.",
+    `Request: ${request}`,
+    `Read: a ${builderFor(route) ? "quick feature" : "quick fix"} — ${route.reasons.join("; ")} (${route.source}).`,
+    "",
+    "Confirm where it goes with route_request, in one step and from the request alone: do not read files, plan or ask.",
+    "- to=quickfix: one agent does it now and the lobby shows it on the Quick fix tab. Right for anything one person can just do, even a rich piece of work in one file.",
+    "- to=task: the team (bot-lobby's workflow), when it needs several areas agreeing on a contract, a survey of an unfamiliar codebase, a risky change, or decisions the user must make first.",
+    "Then tell the user in one line where it went.",
+  ].join("\n");
+}
+
+export interface RequestOptions extends StartOptions {
+  /** `--task`: always a task. */
+  task?: boolean;
+}
+
+/**
+ * A new request from the lobby or `/bot-lobby <request>`: a task at once, or
+ * (when it reads as one agent's work) a question to the oracle first.
+ * Resolves with what happened.
+ */
+export async function startRequest(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: RequestOptions = {}): Promise<"task" | "routing" | undefined> {
+  const { task: asTask, ...start } = options;
+  const config = loadConfig();
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const placed = asTask || start.track || start.approvedPlan || !config.workflow.routeQuickFixes || !handoff;
+  // A session that already drives a task gets startTask's own warning.
+  if (placed || ownedTask(root, configDir, ctx.sessionManager.getSessionId())) {
+    return (await startTask(pi, ctx, configDir, request, start)) ? "task" : undefined;
+  }
+  const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
+  const route = chooseRoute(request, triage, config.classifier.thresholds.quickFixAt);
+  const read: StartOptions = { ...start, triaged: true, ...(triage ? { triage } : {}) };
+  if (route.to === "task") return (await startTask(pi, ctx, configDir, request, read)) ? "task" : undefined;
+  pending = { request, options: read, route, at: Date.now() };
+  lobbyFeed.log("LOBBY", `reads as a ${builderFor(route) ? "quick feature" : "quick fix"} (${route.source}): ${route.reasons[0]} — the oracle confirms`, "info");
+  pi.sendUserMessage(routeMessage(request, route), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  return "routing";
+}
+
+const RouteSchema = Type.Object({
+  to: StringEnum(["quickfix", "task"] as const, { description: "quickfix: one agent does it now, on the lobby's Quick fix tab; task: the team (bot-lobby's workflow)" }),
+  reason: Type.Optional(Type.String({ description: "one line: why it goes there" })),
+  request: Type.Optional(Type.String({ description: "the request as it should be done, when the user refined it since; their words otherwise" })),
+});
+
+/** The oracle's answer to a routing question: the quick-fix agent, or a task. */
+export async function routeRequest(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, params: { to: "quickfix" | "task"; reason?: string; request?: string }): Promise<{ ok: boolean; text: string }> {
+  const waiting = pendingRequest();
+  if (!waiting || !pending) return { ok: false, text: "No request is waiting to be routed. Start a task with /bot-lobby <request>." };
+  const { options, route } = pending;
+  const request = params.request?.trim() || pending.request;
+  pending = undefined;
+  const why = params.reason?.trim();
+  if (params.to === "quickfix") {
+    const id = handoff?.(request, builderFor(route), why || route.reasons[0] || "one agent can do it alone");
+    if (id) {
+      lobbyFeed.log("LOBBY", `the oracle sent it to the quick-fix agent: ${id}${why ? ` — ${why}` : ""}`, "success");
+      return { ok: true, text: `${id} is running on the lobby's Quick fix tab, which is now open. Tell the user in one line that this looks like a ${builderFor(route) ? "quick feature" : "quick fix"} and the quick-fix agent is on it; nothing else to do.` };
+    }
+    // No lobby to run it any more: it becomes a task.
+  }
+  lobbyFeed.log("LOBBY", `the oracle sent it to the team${why ? ` — ${why}` : ""}`, "info");
+  const task = await startTask(pi, ctx, configDir, request, { ...options, routed: true });
+  return task
+    ? { ok: true, text: `Started ${task.id} as a task; its kickoff follows as the next message. Say nothing more now.` }
+    : { ok: false, text: "Could not start a task: this session already drives one (finish or cancel it first)." };
+}
+
+/**
+ * `route_request`, active only while a request waits for the oracle, so it
+ * never sits in the tool list of plain pi or of a running task.
+ */
+export function registerRouteTool(pi: ExtensionAPI, configDir: string): void {
+  if (isSubagentProcess()) return;
+  pi.on("session_start", () => {
+    pending = undefined;
+  });
+  pi.on("before_agent_start", () => {
+    const active = pi.getActiveTools();
+    const want = Boolean(pendingRequest());
+    if (want === active.includes(ROUTE_TOOL)) return;
+    pi.setActiveTools(want ? [...active, ROUTE_TOOL] : active.filter((name) => name !== ROUTE_TOOL));
+  });
+  pi.registerTool({
+    name: ROUTE_TOOL,
+    label: "Route request",
+    description: "Send a new bot-lobby request to the quick-fix agent (to=quickfix: one agent does it now, shown on the lobby's Quick fix tab) or to the team (to=task: bot-lobby's workflow). Only while a request waits to be routed.",
+    promptSnippet: "Route a new bot-lobby request: quickfix (one agent now) or task (the team)",
+    parameters: RouteSchema,
+    renderShell: "self",
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await routeRequest(pi, ctx, configDir, params as { to: "quickfix" | "task"; reason?: string; request?: string });
+      return { content: [{ type: "text", text: result.text }], details: { ok: result.ok, to: (params as { to: string }).to } };
+    },
+    renderCall(args, theme) {
+      if (isQuiet()) return new Container();
+      const call = args as { to?: string };
+      return new Text(`${theme.fg("toolTitle", theme.bold("route_request"))} ${theme.fg("accent", call.to ?? "")}`, 0, 0);
+    },
+    renderResult(result, _options, theme) {
+      if (isQuiet()) return new Container();
+      const details = result.details as { ok?: boolean; to?: string } | undefined;
+      const icon = details?.ok ? theme.fg("success", "✓") : theme.fg("warning", "!");
+      return new Text(`${icon} ${theme.fg("toolTitle", theme.bold("route_request"))} ${theme.fg("muted", `→ ${details?.to === "quickfix" ? "Quick fix tab" : "a task"}`)}`, 0, 0);
+    },
+  });
+}
+
+/** Tests: forget any request waiting for the oracle. */
+export function clearPendingRequest(): void {
+  pending = undefined;
+}

package/src/pi/start-task.ts

@@ -5,7 +5,10 @@
  */
 import { existsSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createTask, taskRequest, type Task } from "../schemas/task.ts";
+import { createTask, taskRequest, type Task, type TaskTrack, type TaskTriage, type TrackPath } from "../schemas/task.ts";
+import type { Domain } from "../schemas/agent.ts";
+import { chooseTrack, trackLine, trackSummary } from "../workflow/track.ts";
+import { lobbyFeed } from "../lobby/feed.ts";
 import { createTaskDir, ensureProjectStructure, nextTaskId, ownedTask, saveTask, taskDirFor } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { transition } from "../state/task-state.ts";
@@ -26,19 +29,51 @@ function uniqueTaskId(root: string, configDir: string, request: string): string
   return id;
 }
 
-export function kickoff(task: Task, budgetMinutes = 0): string {
+/** In a kickoff after the oracle routed the request to the team (the lobby then shows the request once). */
+export const ROUTED_LINE = "Routed: you sent this request to the team.";
+
+/** The fast track's steps: straight to the agents the request needs, QA only for tests, then complete. */
+function fastSteps(track: TaskTrack): string[] {
+  const building = track.roster.filter((member): member is Domain => member === "designer" || member === "backend");
+  const builders = building.length > 1
+    ? `one call with assignments for ${building.join(" and ")}, each task stating the contract between them`
+    : building.length === 1 ? `domain ${building[0]}` : track.roster.includes("qa") ? "domain qa (the change is its tests)" : "the one domain that owns the files";
+  const steps = [
+    ...(track.roster.includes("researcher") ? ["First summon the researcher for the outside facts it needs: orchestrate action=research with a domain and the question."] : []),
+    `Delegate now with orchestrate action=implement: ${builders}; open each task with "Step 1:" (the engine keeps the plan).`,
+    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part (tests): once the change is in, give qa the tests as the last step (action=implement domain=qa), or run action=qa."] : []),
+    "Check `git diff --stat` and the report, then orchestrate action=complete with a one-line summary.",
+  ];
   return [
+    "Fast track: the request reads small and clear, so skip the ceremony: no scouts, no proposal, no plan document.",
+    ...steps.map((step, index) => `${index + 1}. ${step}`),
+    track.roster.includes("qa") ? "" : "No QA gate on this track: nothing here needs tests.",
+    "If the request is bigger, riskier or less clear than it reads, switch before delegating: orchestrate action=track track=full with a reason. Otherwise do not deliberate over the track.",
+  ].filter(Boolean);
+}
+
+export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
+  const track = task.track;
+  const head = [
     `A bot-lobby task is active: ${task.id}`,
     `Title: ${task.title}`,
     `Request: ${taskRequest(task)}`,
     `State: ${task.state}`,
+    ...(options.routed ? [ROUTED_LINE] : []),
+    ...(track ? [trackSummary(track)] : []),
     ...(budgetMinutes > 0 ? [`Time budget: ${budgetMinutes} minutes of work, for you and every agent. Size the plan to fit it and divide it by scope (see Time budget in your prompt).`] : []),
     "",
+  ];
+  if (track?.path === "fast") return [...head, ...fastSteps(track)].join("\n");
+  const fastAllowed = Boolean(track) && options.fastTrack !== false && track?.userChoice !== "full" && track?.source !== "plan";
+  return [
+    ...head,
     "Drive it with the orchestrate tool:",
     "1. clarify if the request is genuinely ambiguous,",
     "2. scout the domains the request touches,",
     "3. synthesize the findings and propose a short `- ` bullet list for approval.",
     "Do not implement anything before the user approves the proposal.",
+    ...(fastAllowed ? ["If it is in fact a small, clear, low-risk change, take the fast track instead: orchestrate action=track track=fast with a reason."] : []),
   ].join("\n");
 }
 
@@ -56,6 +91,13 @@ export interface StartOptions {
   title?: string;
   /** Minutes of work time the task gets; `workflow.taskBudgetMinutes` when absent. */
   budget?: number;
+  /** The user's `--fast` or `--full`: the path the task takes, whatever its request reads as. */
+  track?: TrackPath;
+  /** The classifier already read the request (routing did): `triage` is its read, or absent when it was off. */
+  triaged?: boolean;
+  triage?: TaskTriage;
+  /** The oracle sent this request to the team after the classifier read it as a quick fix. */
+  routed?: boolean;
 }
 
 export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: StartOptions = {}): Promise<Task | undefined> {
@@ -72,10 +114,14 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   createTaskDir(root, configDir, task);
   transition(task, "clarifying");
   // The classifier's read of the request (when it is on) reaches the Master's very first turn.
-  const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
+  const triage = options.triaged ? options.triage : await triageFor({ cwd: ctx.cwd, root, configDir }, request);
   if (triage) task.triage = triage;
+  // How serious the request reads: who takes part, and whether it takes the fast track or the full workflow.
+  const config = loadConfig();
+  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}) });
+  lobbyFeed.log("LOBBY", trackLine(task.track), "info");
   saveTask(root, configDir, task);
-  const budgetMinutes = options.budget ?? loadConfig().workflow.taskBudgetMinutes;
+  const budgetMinutes = options.budget ?? config.workflow.taskBudgetMinutes;
   if (budgetMinutes > 0) setBudget(root, configDir, task.id, budgetMinutes);
   if (options.auto) setAutoMode(root, configDir, task.id, true, sessionId);
   // A session that starts a task is named after it, so /resume and the lobby list it by name.
@@ -86,7 +132,7 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   // The oracle takes the task on with a clean context: nothing said before the kickoff is sent to its model.
   if (freshContextOn()) markContext(pi, { kind: "start", taskId: task.id, at: Date.now() });
   // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
-  pi.sendUserMessage(kickoff(task, budgetMinutes), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  pi.sendUserMessage(kickoff(task, budgetMinutes, { fastTrack: config.workflow.fastTrack, ...(options.routed ? { routed: true } : {}) }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;
 }
 

package/src/pi/tools.ts

@@ -51,7 +51,11 @@ const OrchestrateSchema = Type.Object({
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
   ),
   note: Type.Optional(Type.String({ description: "resolve_approval: rationale, or what to do instead when rejected" })),
-  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time" })),
+  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time; track: why the task takes that path or needs those members" })),
+  track: Type.Optional(
+    StringEnum(["fast", "full"] as const, { description: "track: fast (straight to the roster's agents, no scouts, proposal or plan; QA only for tests) or full (the whole workflow)" }),
+  ),
+  roster: Type.Optional(Type.Array(Type.String(), { description: "track: who takes part — any of designer, backend, qa, researcher" })),
   text: Type.Optional(Type.String({ description: "decide/complete/knowledge: the decision, completion summary, or knowledge text" })),
   file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md" })),
   kind: Type.Optional(
@@ -71,7 +75,8 @@ const DESCRIPTION = [
   "compact (replace a knowledge file with a rewritten version, archiving the old one),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
   "pass), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
-  "user for more minutes with a reason), status, cancel.",
+  "user for more minutes with a reason), track (the task's path and who takes part: show it, or correct it with",
+  "track=fast|full, roster and a reason), status, cancel.",
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
@@ -184,7 +189,7 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
     name: "orchestrate",
     label: "Orchestrate",
     description: DESCRIPTION,
-    promptSnippet: "Run a bot-lobby workflow step (clarify, scout, propose, plan, decide, status, cancel)",
+    promptSnippet: "Run a bot-lobby workflow step (clarify, scout, propose, plan, implement, track, decide, status, cancel)",
     promptGuidelines: [
       "Use orchestrate for every bot-lobby workflow step; it enforces the task state machine and records results.",
     ],

package/src/roles/worker.ts

@@ -76,6 +76,14 @@ export function parseMoreTime(text: string): { minutes?: number; reason: string
   return { ...(minutes && minutes > 0 ? { minutes } : {}), reason: reason || flat };
 }
 
+/** A bullet that says there is nothing: `None.`, `N/A`, `No new dependencies (three.js from a CDN)`. */
+const NOTHING = /^(?:\*\*|_)?(?:none|n\/?a|nil|nothing|not applicable|no(?:ne)?\s+(?:new\s+|additional\s+|extra\s+)?(?:dependenc|packages?|librar|architecture|architectural|changes?\b))/i;
+
+/** Asks that need the Master's approval: a report that lists "None." asks for nothing. */
+export function realAsks(items: readonly string[]): string[] {
+  return items.filter((item) => !NOTHING.test(item.trim()));
+}
+
 /** Parse a worker's markdown into a structured result (never throws). */
 export function parseWorkerResult(domain: Domain, raw: string, now = new Date().toISOString()): WorkerResult {
   const sections = parseSections(raw);
@@ -93,8 +101,8 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
     blockers: parseBlockers(sections, domain, now),
     knowledgeProposals: parseKnowledgeProposals(domain, findSection(sections, "knowledge proposals")),
     pushback: parsePushback(sections),
-    dependencyNeeds: bullets(findSection(sections, "dependencies needed")),
-    architectureChanges: bullets(findSection(sections, "architecture changes")),
+    dependencyNeeds: realAsks(bullets(findSection(sections, "dependencies needed"))),
+    architectureChanges: realAsks(bullets(findSection(sections, "architecture changes"))),
     raw,
   };
 }

package/src/schemas/configuration.ts

@@ -70,6 +70,10 @@ export interface WorkflowConfig {
   freshContext: boolean;
   /** Minutes of work time a new task gets unless it is started with its own (`--budget`); 0 = no budget. */
   taskBudgetMinutes: number;
+  /** Small, clear, low-risk requests take the fast track (no scouts, proposal or plan; QA only when tests are needed); false puts every task on the full workflow. */
+  fastTrack: boolean;
+  /** A new request that one agent can do alone goes to the quick-fix agent once the oracle confirms; false makes every request a task. */
+  routeQuickFixes: boolean;
 }
 
 export interface KnowledgeConfig {
@@ -143,6 +147,8 @@ export interface ClassifierThresholds {
   simpleAt: number;
   /** A step scored trivial at this confidence runs on the cheaper model. */
   trivialAt: number;
+  /** A new request goes to the quick-fix agent when one engineer can do it alone at least this likely (the oracle confirms). */
+  quickFixAt: number;
   /** A quick fix scored large at this confidence is held instead of started. */
   quickFixLargeAt: number;
 }
@@ -207,6 +213,8 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     maxParallelWorkers: 3,
     freshContext: true,
     taskBudgetMinutes: 0,
+    fastTrack: true,
+    routeQuickFixes: true,
   },
   knowledge: {
     compactionThreshold: 20000,
@@ -239,6 +247,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
       fileRelevantAt: 0.5,
       simpleAt: 0.7,
       trivialAt: 0.8,
+      quickFixAt: 0.7,
       quickFixLargeAt: 0.8,
     },
     fileHints: { topK: 8, maxCandidates: 480, budgetMs: 1500 },
@@ -343,6 +352,8 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   const src = (partial ?? {}) as Record<string, unknown>;
   const workflow = { ...DEFAULT_CONFIG.workflow, ...(src.workflow as Partial<WorkflowConfig> | undefined) };
   workflow.freshContext = workflow.freshContext !== false;
+  workflow.fastTrack = workflow.fastTrack !== false;
+  workflow.routeQuickFixes = workflow.routeQuickFixes !== false;
   workflow.taskBudgetMinutes = typeof workflow.taskBudgetMinutes === "number" && workflow.taskBudgetMinutes > 0 ? Math.min(24 * 60, Math.round(workflow.taskBudgetMinutes)) : 0;
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };
   const srcAgents = (src.agents ?? {}) as Partial<BotLobbyConfig["agents"]>;

package/src/schemas/task.ts

@@ -108,12 +108,41 @@ export interface TaskTriage {
   research: number;
   /** How likely it is ambiguous as written. */
   ambiguous: number;
+  /** How likely one engineer can do it alone, right away (a quick fix, not a task for the team). */
+  solo?: number;
   kind?: string;
   kindProbability?: number;
   likelyFiles?: string[];
   at: string;
 }
 
+/** How much process a task gets: the fast track for a small, clear, low-risk change, the full workflow for the rest. */
+export type TrackPath = "fast" | "full";
+
+/** Who can take part in a task: the three domains and the researcher. */
+export type TrackMember = Domain | "researcher";
+
+/**
+ * How serious the request reads, and so who takes part and how much process
+ * it gets. The engine reads it as the task starts; the oracle may correct it
+ * (`action=track`) and the user may force the path (`--fast`, `--full`).
+ */
+export interface TaskTrack {
+  path: TrackPath;
+  size: TriageSize;
+  /** Who takes part: the domains that build, QA when the change needs tests, the researcher when it needs outside facts. */
+  roster: TrackMember[];
+  /** Why, a few words each. */
+  reasons: string[];
+  /** Who set it: the engine's rules, the classifier's triage, the user, the oracle, or a plan agreed in the planning panel. */
+  source: "rules" | "classifier" | "user" | "oracle" | "plan";
+  /** The path the user asked for with --fast or --full; the oracle never moves a task off it toward less process. */
+  userChoice?: TrackPath;
+  /** The engine keeps the plan (fast track): each delegation adds its step. */
+  autoPlan?: boolean;
+  at: string;
+}
+
 /** What the working tree held when a task's agents started editing: its changed files, repository-relative, and the commit it stood on. */
 export interface ChangeBaseline {
   at: string;
@@ -160,6 +189,8 @@ export interface Task {
   archivedAt?: string;
   /** The classifier's read of the request, when it was on as the task started. */
   triage?: TaskTriage;
+  /** The task's track; absent on tasks created before tracks, which take the full workflow. */
+  track?: TaskTrack;
   /** Files already changed when the first worker started: the QA gate reads them as pre-existing, not as this task's work. */
   baseline?: ChangeBaseline;
   /** Review rounds the user granted past `workflow.maxReviewIterations`. */