@a-t-h-i/bot-lobby 0.6.57 → 0.6.59

package/src/lobby/runtime.ts

@@ -1,6 +1,6 @@
 /**
  * The lobby inside pi: one runtime per master session. It owns the lobby's
- * state (the quick-fix queue, planner, issues, pulls, knowledge), narrates the
+ * state (the chat agents, planner, issues, pulls, knowledge), narrates the
  * Master's own turn into the feed, passes plan comments to the Master that
  * owns a task and records each Master turn in the metrics log. The web server
  * (src/webui) is its only surface.
@@ -15,19 +15,17 @@ import { basename } from "node:path";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { modelRef } from "../pi/model-support.ts";
 import { modelLookup } from "../pi/tools.ts";
-import { setQuickFixHandoff } from "../pi/route.ts";
-import type { Domain } from "../schemas/agent.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
 import { classifier, effortFor, hintsFor, scriptsPickerFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
-import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
+import { ChatAgents } from "./chat-agents.ts";
 import { execCommand, IssuesState } from "./issues.ts";
 import { PullsState } from "./pulls.ts";
 import { PullReviews } from "./pr-review.ts";
 import { KnowledgeBook } from "./knowledge.ts";
 import type { LobbyService } from "./host.ts";
-import { backgroundSessions, carryHandOff, createLobbyService, lobbyNotify, lobbyProfile, plannerDeps, resumeSession, reviewProfile, seatProfile, setServiceState, savePlan as serviceSavePlan, answerPanel as serviceAnswerPanel } from "./service.ts";
+import { backgroundSessions, carryHandOff, chatProfile, chatReplied, chatHistoryLines, createLobbyService, lobbyNotify, lobbyProfile, plannerDeps, resumeSession, reviewProfile, seatProfile, setServiceState, savePlan as serviceSavePlan, answerPanel as serviceAnswerPanel } from "./service.ts";
 import { lobbyTopics } from "./topics.ts";
 export { backgroundSessions, setSessionLauncher } from "./service.ts";
 import { deliverComments, onOwnerEvent } from "../pi/owner.ts";
@@ -42,7 +40,8 @@ export interface Runtime {
   configDir: string;
   ctx: ExtensionContext;
   root: string;
-  quickfix: QuickFixQueue;
+  /** The lobby chat's agents other than the oracle, answering one at a time. */
+  chat: ChatAgents;
   planner?: PlanningSession;
   issues: IssuesState;
   pulls: PullsState;
@@ -80,11 +79,11 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   return serviceAnswerPanel(state);
 }
 
-/** What the lobby is running now (a quick fix, a review, a planning round), in words, or undefined. */
+/** What the lobby is running now (a chat agent's reply, a review, a planning round), in words, or undefined. */
 export function lobbyWorkRunning(): string | undefined {
   const state = runtime;
   if (!state) return undefined;
-  if (state.quickfix.running) return "A quick fix";
+  if (state.chat.running) return "A chat reply";
   if (state.planner?.busy) return "A planning round";
   if (state.reviews.busy) return "A pull request review";
   return undefined;
@@ -107,32 +106,13 @@ function shutdown(carryOn: boolean): void {
   runtime = undefined;
   lobbyService = undefined;
   setServiceState(undefined);
-  setQuickFixHandoff(undefined);
   state.unsubscribeFeed?.();
-  state.quickfix.cancelAll();
+  state.chat.cancelAll();
   state.reviews.cancelAll();
   state.planner?.cancel();
   onRunUpdates(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 tell the page where it went.
- */
-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 grants.` : ""}`,
-  });
-  lobbyTopics.bump("quickfix");
-  pushNotice("The oracle sent your request to the quick-fix agent.", "info");
-  return job.id;
-}
-
 /**
  * Start the lobby's backend: state, service and background wiring. Runs for
  * every interactive master session, not a subagent.
@@ -150,10 +130,10 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     asking: false,
     workspace: { name: basename(ctx.cwd) || ctx.cwd },
     readingWorkspace: false,
-    quickfix: undefined as unknown as QuickFixQueue,
     issues: new IssuesState(execCommand, ctx.cwd, () => lobbyTopics.bump("issues")),
     pulls: new PullsState(execCommand, ctx.cwd, () => lobbyTopics.bump("git")),
     reviews: undefined as unknown as PullReviews,
+    chat: undefined as unknown as ChatAgents,
     knowledge: new KnowledgeBook({
       root,
       configDir,
@@ -175,34 +155,30 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     notify: (message, level) => lobbyNotify(state, message, level),
     classifier: classifier(),
   });
-  state.quickfix = new QuickFixQueue({
+  state.chat = new ChatAgents({
     cwd: ctx.cwd,
     root,
     configDir,
-    profile: () => lobbyProfile(state, "quickfix"),
-    stallTimeoutMs: workflow.stallTimeoutMs,
-    toolStallTimeoutMs: workflow.toolStallTimeoutMs,
-    feed: lobbyFeed,
+    profile: (agent) => chatProfile(state, agent),
+    history: chatHistoryLines,
+    onReply: (job) => chatReplied(state, job),
     onChange: () => {
-      lobbyTopics.bump("quickfix");
-      state.keeper?.quickfix.schedule();
+      lobbyTopics.bump("lobby");
+      lobbyTopics.bump("status");
     },
-    notify: (message, level) => lobbyNotify(state, message, level),
+    feed: lobbyFeed,
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
-    scripts: scriptsPickerFor(),
-    classifier: classifier(),
-    effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
-    lint: () => loadConfig().lint,
+    stallTimeoutMs: workflow.stallTimeoutMs,
+    toolStallTimeoutMs: workflow.toolStallTimeoutMs,
   });
   runtime = state;
   lobbyService = createLobbyService(state);
   setServiceState(state);
   // Topic routing (src/lobby/topics.ts): sources bump a topic when their data
   // changes and the web page rereads it. lobbyFeed (lobby), run updates (tasks),
-  // quick fix (quickfix), planner (planner), background sessions (sessions),
+  // chat agents (lobby), planner (planner), background sessions (sessions),
   // metrics (metrics), pulls/reviews (git), issues (issues), the prompt hub
   // (prompts), owner/notify events (notices), busy/workspace (status).
-  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));
@@ -219,6 +195,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     if (event.kind === "comments") lobbyFeed.log("LOBBY", `passed ${event.count} plan comment${event.count === 1 ? "" : "s"} on ${event.taskId} to the oracle`, "info");
     else if (event.kind === "inbox" || event.kind === "messages") lobbyFeed.log("LOBBY", `passed ${event.count} message${event.count === 1 ? "" : "s"} from another session to the oracle`, "info");
     else if (event.kind === "auto") lobbyFeed.log("LOBBY", `auto mode ${event.on ? "on" : "off"} for ${event.taskId}`, event.on ? "success" : "info");
+    else if (event.kind === "held") lobbyFeed.log("LOBBY", `auto mode: you stopped the oracle on ${event.taskId}; it waits for your next message`, "info");
     else if (event.kind === "nudge") lobbyFeed.log("LOBBY", `auto mode: keeping the oracle going on ${event.taskId}`, "info");
     else lobbyFeed.log("LOBBY", `auto mode: no progress on ${event.taskId} — it needs you`, "warning");
   });
@@ -239,7 +216,6 @@ function carryOn(state: Runtime): void {
     sessionFile: () => state.ctx.sessionManager.getSessionFile?.(),
     working: () => !state.ctx.isIdle(),
     planner: () => state.planner,
-    quickfix: () => state.quickfix.snapshot(),
     background: () => backgroundSessions(),
   });
   let summary: string | undefined;
@@ -250,7 +226,6 @@ function carryOn(state: Runtime): void {
       sessionId: ctx.sessionManager.getSessionId(),
       relaunch: (start) => resumeSession(state, start),
       restorePlanner: (snapshot) => restorePlanner(state, snapshot),
-      restoreQuickFixes: (jobs) => state.quickfix.restore(jobs).length,
       nudge: (message) => nudgeWhenIdle(state, message),
     });
   } catch (error) {
@@ -359,6 +334,9 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
     const finished = turn;
     turn = undefined;
     lobbyFeed.replyEnd();
+    // A tool call cut off by a stop or a steer never ends on its own; the turn's end closes it.
+    lobbyFeed.endAll("MASTER");
+    lobbyTopics.bump("status");
     const taskId = finished?.taskId ?? currentZenTask()?.id;
     if (!finished || !taskId || !runtime) return;
     appendMetrics(runtime.root, configDir, [{
@@ -378,6 +356,10 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
       taskId,
     }]);
     lobbyTopics.bump("metrics");
+  });
+  // pi is idle only once the run has settled (after agent_end, retries and continuations): the page's busy flag rereads then.
+  pi.on("agent_settled", () => {
+    lobbyFeed.endAll("MASTER");
     lobbyTopics.bump("status");
   });
 }

package/src/lobby/service.ts

@@ -29,12 +29,14 @@ import { applyStatus, currentZenTask, taskSnapshot } from "../pi/ui.ts";
 import { taskName } from "../text.ts";
 import { describeWorkspace } from "../execution/workspace.ts";
 import { stripStartFlags } from "../pi/start-flags.ts";
-import { checkThinking, modelRef, resolveLobbyProfile, resolvePanelProfile, resolveReviewProfile, supportedThinking } from "../pi/model-support.ts";
+import { checkThinking, modelRef, resolveChatProfile, resolveLobbyProfile, resolvePanelProfile, resolveReviewProfile, supportedThinking } from "../pi/model-support.ts";
 import { modelLookup } from "../pi/tools.ts";
-import { startPlannedTask } from "../pi/start-task.ts";
-import { pendingRequest, startRequest } from "../pi/route.ts";
+import { startPlannedTask, startTask } from "../pi/start-task.ts";
 import { deliverComments, setAuto } from "../pi/owner.ts";
-import { chatFromEntries, lobbyFeed, type ChatEntry } from "./feed.ts";
+import { CHAT_MARK, chatFromEntries, chatMarkContent, CLEARED_NOTE, lobbyFeed, type ChatEntry, type ChatMarkDetails } from "./feed.ts";
+import { CHAT_AGENT_SOURCES, parseLobbyCommand, parseMention, type LobbyCommand } from "./prompts.ts";
+import type { ChatJob, ChatWorker } from "./chat-agents.ts";
+import { routeChatMessage } from "../classifier/lobby.ts";
 import { availableClassifiers, classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { cleanSessionName, launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { askForSession } from "./session-questions.ts";
@@ -147,23 +149,144 @@ function failed(state: Runtime, what: string, error: Error): void {
   lobbyNotify(state, `bot-lobby: ${what} — ${error.message}`, "error");
 }
 
-function toOracle(state: Runtime, text: string): string | undefined {
+/** What sending to the lobby chat did: nothing to say, a notice, or a notice and the tab to open. */
+export type LobbySendResult = string | { notice: string; open: "plan" } | undefined;
+
+function toOracle(state: Runtime, text: string): LobbySendResult {
   const busy = !state.ctx.isIdle();
+  const command = parseLobbyCommand(text);
+  if (command) return lobbyCommand(state, command.command, command.rest);
   if (text.startsWith("/")) {
     state.pi.sendUserMessage(text, { expandPromptTemplates: true, ...(busy ? { deliverAs: "followUp" as const } : {}) });
     return `sent ${text.split(/\s+/)[0]} to pi`;
   }
-  // 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";
+  // A task in this session: the oracle drives it, and what you say goes to it.
+  if (currentZenTask()) return toMaster(state, text);
+  const mention = parseMention(text);
+  if (mention?.agent === "master") return toMaster(state, mention.rest.trim() || text);
+  if (mention) {
+    const body = mention.rest.trim();
+    if (!body) return `say what you want ${CHAT_AGENT_SOURCES[mention.agent]} to do after @${mention.agent === "designer" ? "design" : mention.agent === "backend" ? "dev" : mention.agent === "researcher" ? "research" : mention.agent}`;
+    toAgent(state, mention.agent, body, `you named ${CHAT_AGENT_SOURCES[mention.agent]}`);
+    return undefined;
   }
+  // While the oracle is mid-turn, what you say steers it, as it always has.
+  if (busy) return toMaster(state, text);
+  lobbyFeed.sayQueued(text);
+  void routeChat(state, text).catch((error: Error) => failed(state, "could not pass your message on", error));
+  return undefined;
+}
+
+/** The oracle answers: a pi turn, or a steer while it is mid-turn. */
+function toMaster(state: Runtime, text: string): undefined {
+  const busy = !state.ctx.isIdle();
   state.pi.sendUserMessage(text, busy ? { deliverAs: "steer" } : undefined);
   // A steer reaches the oracle only when its turn lets it in; the conversation shows it now.
   if (busy) lobbyFeed.sayQueued(text);
   return undefined;
 }
 
+/** One line of the conversation as an agent reads it. */
+function chatLine(entry: ChatEntry): string {
+  if (entry.role === "you") return `You${entry.to ? ` (to ${entry.to})` : ""}: ${entry.text}`;
+  if (entry.role === "note") return `(${entry.text})`;
+  return `${entry.agent ?? "MASTER"}: ${entry.text}`;
+}
+
+/** The conversation since the oracle's context was last cleared, as lines. */
+export function chatHistoryLines(): string[] {
+  const chat = lobbyFeed.chat;
+  const cleared = chat.map((entry) => entry.text).lastIndexOf(CLEARED_NOTE);
+  return chat.slice(cleared + 1).map(chatLine);
+}
+
+/** Who answers a message nobody was named in: the classifier's pick when it is sure, else the Master. */
+async function routeChat(state: Runtime, text: string): Promise<void> {
+  const jev = classifier();
+  const lines = chatHistoryLines();
+  const picked = jev ? await routeChatMessage(jev, text, lines.slice(-7, -1), { at: loadConfig().classifier.thresholds.lobbyAgentAt }).catch(() => undefined) : undefined;
+  if (state !== serviceState) return;
+  if (!picked || picked.route === "master") {
+    toMaster(state, text);
+    return;
+  }
+  if (picked.route === "knowledge") {
+    lobbyFeed.log("LOBBY", `a knowledge question (${picked.probability.toFixed(2)}): the oracle reads the project's knowledge`, "info");
+    state.pi.sendUserMessage(knowledgeQuestion(text, readDataRoots(state.root, state.configDir)), state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+    return;
+  }
+  toAgent(state, picked.route, text, `the classifier picked ${CHAT_AGENT_SOURCES[picked.route]} (${picked.probability.toFixed(2)})`, true);
+}
+
+/** An agent other than the oracle answers: the message joins the conversation (and the session) under its name, and its reply follows. */
+function toAgent(state: Runtime, agent: ChatWorker, text: string, why: string, shown = false): void {
+  const source = CHAT_AGENT_SOURCES[agent];
+  if (shown) {
+    lobbyFeed.takeQueued(text);
+    lobbyFeed.addressed(text, source);
+  } else lobbyFeed.say("you", text, Date.now(), { to: source });
+  keepChatLine(state, { role: "you", agent: source, text });
+  lobbyFeed.log("LOBBY", `${source} answers: ${why}`, "info");
+  state.chat.submit(agent, text, why);
+}
+
+/** Keep a line the oracle did not take part in, in its session: it reads it as context, and the conversation shows it again later. */
+function keepChatLine(state: Runtime, details: ChatMarkDetails): void {
+  try {
+    state.pi.sendMessage({ customType: CHAT_MARK, content: chatMarkContent(details), display: true, details }, { triggerTurn: false });
+  } catch {
+    // A session that cannot take it keeps the conversation in the page alone.
+  }
+}
+
+/** A chat agent finished: its reply joins the conversation and the session. */
+export function chatReplied(state: Runtime, job: ChatJob): void {
+  const source = CHAT_AGENT_SOURCES[job.agent];
+  const text = job.reply ?? (job.status === "success" ? "(no reply)" : "");
+  if (text) {
+    lobbyFeed.say("oracle", text, job.finishedAt ?? Date.now(), { agent: source });
+    keepChatLine(state, { role: "agent", agent: source, text });
+  }
+  if (job.status !== "success" && job.status !== "cancelled") lobbyFeed.say("note", `✗ ${source}'s reply ${job.status}${job.error ? `: ${job.error.split("\n")[0]}` : ""}`);
+}
+
+/** The model, thinking and grants a chat agent answers with. */
+export function chatProfile(state: Runtime, agent: ChatWorker) {
+  return resolveChatProfile(loadConfig(), agent, {
+    lookup: modelLookup(state.ctx),
+    sessionModel: sessionModel(state.ctx),
+    warn: (message) => lobbyNotify(state, message, "warning"),
+  });
+}
+
+/** The work a bare `/plan` or `/task` is about: the conversation so far. */
+function fromConversation(): string | undefined {
+  const lines = chatHistoryLines().filter((line) => !line.startsWith("("));
+  if (!lines.some((line) => line.startsWith("You"))) return undefined;
+  return `From the lobby chat:\n\n${lines.slice(-12).join("\n\n")}`;
+}
+
+/** `/plan` and `/task`: plan the work with the panel on the Plan tab, or start it as a task. */
+function lobbyCommand(state: Runtime, command: LobbyCommand, rest: string): LobbySendResult {
+  const request = rest.trim() || fromConversation();
+  if (!request) return `type what to ${command === "plan" ? "plan" : "do"} after /${command}`;
+  if (command === "task") {
+    const current = currentZenTask();
+    if (current) return `this session already drives ${current.id}; finish or cancel it first, or start the task from another session`;
+    startTask(state.pi, state.ctx, state.configDir, request)
+      .then(() => lobbyTopics.bump("tasks"))
+      .catch((error: Error) => failed(state, "could not start the task", error));
+    return "starting a task — the oracle takes it from here";
+  }
+  if (state.planner?.busy) return "the panel is still thinking — wait for the round to finish";
+  // A plan under way stays among the project's previous plans; this one starts afresh.
+  const fresh = state.planner && state.planner.messages.length > 0;
+  const session = fresh || !state.planner ? newPlanner(state, undefined, loadConfig().lobby.planningPanel) : state.planner;
+  session.send(request).catch((error: Error) => failed(state, "could not start planning", error));
+  lobbyTopics.bump("planner");
+  return { notice: fresh ? "planning on the Plan tab — your earlier plan is under Previous plans" : "planning on the Plan tab", open: "plan" };
+}
+
 function startPlanned(state: Runtime, plan: PlannedTask): string {
   const current = currentZenTask();
   if (current) return `this session already drives ${current.id}; finish or cancel it first, or start ${plan.id} from another session`;
@@ -580,7 +703,7 @@ function liveSessions(state: Runtime): LiveSession[] {
  */
 function chatHistory(state: Runtime, sessionId?: string): ChatEntry[] {
   if (sessionId) return chats.history(sessionId);
-  return chatFromEntries(state.ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY).map((line, index) => ({ id: -(index + 1), at: line.at ?? 0, role: line.role, text: line.text }));
+  return chatFromEntries(state.ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY).map((line, index) => ({ ...line, id: -(index + 1), at: line.at ?? 0 }));
 }
 
 /** Leave a message for a session running in another terminal. */
@@ -914,7 +1037,11 @@ export function createLobbyService(state: Runtime): LobbyService {
       return { ...(snapshot.task ? { task: snapshot.task } : {}), runs: snapshot.runs };
     },
     feed: lobbyFeed,
-    masterBusy: () => !state.ctx.isIdle(),
+    masterBusy: () => !state.ctx.isIdle() || state.chat.busy,
+    answering: () => {
+      const job = state.chat.running;
+      return job ? CHAT_AGENT_SOURCES[job.agent] : undefined;
+    },
     tasks: () => peekTasks(state.root, state.configDir),
     work: (taskId) => taskWork(state.root, state.configDir, taskId),
     deliveryDeliver: (taskId, request: DeliveryRequest) => deliver(request, { cwd: state.root, exec: execCommand }, deliveryStore(state.root, state.configDir, taskId)),
@@ -952,8 +1079,10 @@ export function createLobbyService(state: Runtime): LobbyService {
       discardPlannedTask(state.root, state.configDir, id);
       lobbyTopics.bump("plans");
     },
-    abortMaster: () => state.ctx.abort(),
-    quickfix: state.quickfix,
+    abortMaster: () => {
+      state.chat.cancelAll();
+      if (!state.ctx.isIdle()) state.ctx.abort();
+    },
     planner: () => state.planner,
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
     previousPlans: (archived) => plansBefore(state, archived),

package/src/lobby/session-files.ts

@@ -7,7 +7,7 @@
  * parent, and the text of user and assistant messages (never tool output).
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
-import { chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
+import { chatMarkLine, chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
 
 /** What a session log keeps of one entry: its parent, and its conversation lines if it is a message. */
 interface LogNode {
@@ -96,6 +96,9 @@ export class SessionLog {
       if (chat.length > 0) node.chat = chat;
     } else if (isClearedMark(entry)) {
       node.chat = [{ id: ++logIds, at, role: "note", text: CLEARED_NOTE }];
+    } else {
+      const marked = chatMarkLine(entry);
+      if (marked) node.chat = [{ ...marked, id: ++logIds, at }];
     }
     this.nodes.set(entry.id, node);
     this.leaf = entry.id;

package/src/lobby/topics.ts

@@ -10,7 +10,6 @@ export const LOBBY_TOPICS = [
   "tasks",
   "plans",
   "planner",
-  "quickfix",
   "sessions",
   "metrics",
   "git",

package/src/master/master.ts

@@ -423,7 +423,7 @@ export interface ReviewerRequest {
   workerSummary: string;
   scoutOutcomes: ScoutOutcome[];
   diff: string;
-  /** Who changed each changed file (planned, quick fix, pre-existing, …), one line each. */
+  /** Who changed each changed file (planned, lobby chat, pre-existing, …), one line each. */
   provenance?: string;
   /** What the previous QA round asked for, when there was one: this round verifies it. */
   previousRound?: string;

package/src/pi/commands.ts

@@ -23,8 +23,7 @@ import { applyStatus, registerRevealShortcut } from "./ui.ts";
 import { isOn, registerSwitch, turnOff, turnOn } from "./switch.ts";
 import { classifierSummary } from "./model-settings.ts";
 import { keyStatus } from "../classifier/instance.ts";
-import { kickoff, startPlannedTask } from "./start-task.ts";
-import { startRequest } from "./route.ts";
+import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 import { registerWebServer, webCommand } from "../webui/command.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
@@ -37,8 +36,8 @@ import { livePresence } from "../state/presence.ts";
 import { carryOnMessage } from "../lobby/resume.ts";
 
 const HELP = [
-  "/bot-lobby                  Open the web lobby in your browser: tasks, plan, quick fix, metrics",
-  "/bot-lobby <request>        Start a request: a quick fix when one agent can do it alone (the oracle confirms), else a task",
+  "/bot-lobby                  Open the web lobby in your browser: chat, tasks, plan, metrics",
+  "/bot-lobby <request>        Start a task (in the lobby, /task <request> does the same)",
   "/bot-lobby --task [--auto] <request>   Always a task (also when the request begins with a subcommand word)",
   "/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 --branch|--worktree|--no-branch <request>   Give the task its own git branch, or its own worktree, named after it (or neither), whatever workflow.gitIsolation says",
@@ -80,7 +79,7 @@ export interface ParsedCommand {
   auto?: boolean;
   /** `--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`: the rest is a task's request, even when it begins with a subcommand word. */
   task?: boolean;
   /** `--branch`, `--worktree` or `--no-branch`: the task's git isolation, whatever the config says. */
   isolation?: GitIsolation;
@@ -336,13 +335,12 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto, track, task, isolation } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, track, isolation } = parseCommand(args ?? "");
       // A request, the bare command or anything that drives a task needs bot-lobby on (`web stop` does not).
       if (!sub || (TURNS_ON.has(sub) && !(sub === "web" && rest[0] === "stop"))) turnOn(pi, ctx, configDir);
       if (!sub) {
         if (!restText) return webCommand(ctx, undefined);
-        // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
-        await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
+        await startTask(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(track ? { track } : {}), ...(isolation ? { isolation } : {}) });
         return;
       }
       switch (sub) {

package/src/pi/events.ts

@@ -55,6 +55,14 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
  * operating prompt is patched into the system prompt as one cache-stable
  * section rather than replacing the whole prompt.
  */
+/** What the oracle is told while no task runs: the lobby is a chat, and the workflow waits for /plan or /task. */
+export const LOBBY_CHAT_NOTE = [
+  "## Bot Lobby chat",
+  "You are the Master in Bot Lobby's chat: the user talks to the team here, and everyday work (questions, code changes, updates, minor fixes) happens in the chat itself, so do it directly.",
+  "DESIGN, DEV, QA, RESEARCH and the scout answer in this chat too when the user names one with @ or the classifier gives a message to one; those lines reach you as \"The user asked …\" and \"… answered\" messages, for context: you need not answer them.",
+  "Bot Lobby's workflow (scouts, a plan, the QA gate) runs only when the user types /plan (plan it with the panel) or /task (start it as a task). When a request is large, risky or spans several areas, suggest one of them in a line; never start one yourself.",
+].join("\n");
+
 export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   // Web tools the oracle put away for the task in hand, given back when it ends.
   let hiddenWeb: string[] = [];
@@ -121,10 +129,10 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       }
     }
     if (!task) {
-      // After a task ended and cleared the context, a line on where its record is, in case the user refers back to it.
+      // The lobby chat, and 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"];
+      if (isSubagentProcess() || hidden) delete event.systemPromptOptions.sections["bot-lobby"];
+      else event.systemPromptOptions.sections["bot-lobby"] = [LOBBY_CHAT_NOTE, previous ?? ""].filter(Boolean).join("\n\n");
       return;
     }
     const dataRoots = readDataRoots(root, configDir);

package/src/pi/fresh-context.ts

@@ -9,7 +9,7 @@
  *
  * A boundary is a custom entry in the session file, which is never sent to
  * the model: it survives /resume and belongs to the branch it was made on.
- * Subagents (scouts, workers, reviewers, the planning panel, quick fixes)
+ * Subagents (scouts, workers, reviewers, the planning panel, lobby chat agents)
  * already run as pi processes of their own, each with its own context, and
  * are not touched here.
  */

package/src/pi/model-settings.ts

@@ -30,7 +30,6 @@ export function entryView(config: BotLobbyConfig, kind: SettingsKind): EntryView
   if (kind === "master") return config.master;
   if (kind === "scout") return { model: config.scout.model };
   if (kind === "researcher") return config.researcher;
-  if (kind === "quickfix") return config.quickFix;
   if (kind === "planner") return config.planner;
   return config.agents[kind];
 }
@@ -47,7 +46,6 @@ export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: En
   if (kind === "master") next.master = { ...config.master, ...patch } as AgentModelConfig;
   else if (kind === "scout") next.scout = { ...config.scout, model: patch.model ?? config.scout.model };
   else if (kind === "researcher") next.researcher = { ...config.researcher, ...patch } as AgentModelConfig;
-  else if (kind === "quickfix") next.quickFix = { ...config.quickFix, ...patch } as AgentModelConfig;
   else if (kind === "planner") next.planner = { ...config.planner, ...patch } as AgentModelConfig;
   else next.agents[kind] = { ...config.agents[kind], ...patch } as AgentModelConfig;
   return next;

package/src/pi/model-support.ts

@@ -53,7 +53,6 @@ const LABELS: Record<SubagentKind | "master", string> = {
   qa: "QA",
   scout: "Scout",
   researcher: "Researcher",
-  quickfix: "Quick fix",
   planner: "Planner",
 };
 
@@ -127,6 +126,17 @@ export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember,
   return resolveRunProfile(panelMemberProfile(config, member), kindLabel(member), options);
 }
 
+/**
+ * A lobby chat agent's model, thinking and grants: the domain's (or the
+ * researcher's) settings, as on the planning panel; the scout's own model at
+ * its fixed thinking.
+ */
+export function resolveChatProfile(config: BotLobbyConfig, agent: "designer" | "backend" | "qa" | "researcher" | "scout", options: ResolverOptions): RunProfile {
+  if (agent !== "scout") return resolvePanelProfile(config, agent, options);
+  const profile = agentProfile(config, "backend", "scout");
+  return resolveRunProfile({ model: profile.model, thinking: profile.thinking, ...(profile.mcpTools ? { mcpTools: profile.mcpTools } : {}), ...(profile.skills ? { skills: profile.skills } : {}), ...(profile.autoCompact === false ? { autoCompact: false } : {}), ...(profile.compactAt ? { compactAt: profile.compactAt } : {}), ...(profile.harness ? { harness: profile.harness } : {}) }, kindLabel("scout"), options);
+}
+
 /**
  * The model, thinking and grants a pull request review runs on: QA's, the
  * agent whose job is judging work, with its custom instructions.
@@ -144,7 +154,6 @@ export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup,
     ["backend", config.agents.backend.model, config.agents.backend.thinking],
     ["qa", config.agents.qa.model, config.agents.qa.thinking],
     ["researcher", config.researcher.model, config.researcher.thinking],
-    ["quickfix", config.quickFix.model, config.quickFix.thinking],
     ["planner", config.planner.model, config.planner.thinking],
   ];
   return entries.flatMap(([kind, ref, level]) => {

package/src/pi/owner.ts

@@ -32,7 +32,8 @@ export type OwnerEvent =
   | { kind: "messages"; count: number }
   | { kind: "auto"; taskId: string; on: boolean }
   | { kind: "nudge"; taskId: string }
-  | { kind: "stalled"; taskId: string };
+  | { kind: "stalled"; taskId: string }
+  | { kind: "held"; taskId: string };
 
 interface Owner {
   pi: ExtensionAPI;
@@ -43,6 +44,8 @@ interface Owner {
   configDir: string;
   timer?: ReturnType<typeof setInterval>;
   auto?: AutoTrack;
+  /** The user stopped the oracle: auto mode waits until they start a turn again or switch it. */
+  held?: boolean;
   /** The session's task as this tick read it: one read serves the whole tick. */
   tick?: { task: Task | undefined };
 }
@@ -177,7 +180,7 @@ export function driveAuto(): boolean {
     state.auto = undefined;
     return false;
   }
-  if (!state.ctx.isIdle()) return false;
+  if (state.held || !state.ctx.isIdle()) return false;
   const step = autoStep(state.auto, taskFingerprint(task));
   state.auto = step.track;
   if (step.stalledNow) {
@@ -199,6 +202,7 @@ export function setAuto(root: string, configDir: string, taskId: string, on: boo
   const task = ownTask(state);
   if (task?.id !== taskId) return;
   state.auto = undefined;
+  state.held = false;
   if (on) driveAuto();
 }
 
@@ -213,6 +217,27 @@ export function toggleOwnAuto(): string {
   return on ? `auto mode on for ${task.id}: the oracle drives it to completion without asking you` : `auto mode off for ${task.id}: the oracle asks you again`;
 }
 
+/** Whether a finished turn was stopped by the user (its last reply was aborted). */
+export function stoppedTurn(messages: readonly unknown[] | undefined): boolean {
+  const last = [...(messages ?? [])].reverse().find((message) => (message as { role?: string })?.role === "assistant") as { stopReason?: string } | undefined;
+  return last?.stopReason === "aborted";
+}
+
+/**
+ * A turn ended. One the user stopped holds auto mode, so the next tick does
+ * not start the task again; any turn that starts after it (the user's next
+ * message) lets auto mode carry on.
+ */
+export function turnEnded(messages: readonly unknown[] | undefined): void {
+  const state = owner;
+  if (!state || !stoppedTurn(messages)) return;
+  const task = ownTask(state);
+  if (state.held || !live(task) || !isAutoMode(state.root, state.configDir, task.id)) return;
+  state.held = true;
+  state.auto = undefined;
+  listener?.({ kind: "held", taskId: task.id });
+}
+
 /** One tick of the owner's clock. */
 export function ownerTick(): void {
   const state = owner;
@@ -260,8 +285,14 @@ export function registerOwner(pi: ExtensionAPI, configDir: string): void {
   };
   pi.on("session_start", (_event, ctx) => startOwner(pi, ctx, configDir));
   pi.on("session_shutdown", () => stop());
-  pi.on("agent_start", (_event, ctx) => track(ctx));
-  pi.on("agent_end", (_event, ctx) => track(ctx));
+  pi.on("agent_start", (_event, ctx) => {
+    track(ctx);
+    if (owner) owner.held = false;
+  });
+  pi.on("agent_end", (event, ctx) => {
+    track(ctx);
+    turnEnded((event as { messages?: readonly unknown[] }).messages);
+  });
   // Auto mode has nobody to answer a question: tell the oracle to decide instead.
   pi.on("tool_call", (event, ctx) => {
     if (event.toolName !== "ask_user_question" || !owner) return undefined;