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

package/README.md

@@ -16,20 +16,26 @@ Requires **Pi 1.3.x** (1.3.0 or later).
 
 ## Use
 
-1. In Pi, run `/bot-lobby add a login page`. The lobby opens in your browser. `Ctrl+Shift+M` or
-   `/bot-lobby on|off` switches bot-lobby on or off; a new Pi session starts with it off.
-2. Answer the oracle's questions and approve its plan, or agree on one with the panel in **Plan** first.
-3. Follow the agents in **Lobby** and **Tasks**. Their steps fold into one line in the conversation
-   and open in place.
-
-Small changes go to **Quick fix**. `--task` forces a full task, `--fast` / `--full` picks the workflow,
-and `--branch` / `--worktree` isolates it in git. Workers never commit: the oracle commits only the
+1. In Pi, run `/bot-lobby` to open the lobby in your browser. `Ctrl+Shift+M` or `/bot-lobby on|off`
+   switches bot-lobby on or off; a new Pi session starts with it off.
+2. Chat with the team in **Lobby**. Questions, code changes and small fixes happen right there: the
+   classifier hands each message to the agent whose area it is (a styling question to DESIGN, a
+   library question to RESEARCH, "where is this?" to a scout), and every reply is labelled with who
+   wrote it. Start a message with `@design`, `@dev`, `@qa`, `@research`, `@scout` or `@master` to pick
+   who answers yourself.
+3. Type `/plan <idea>` to plan it with the panel in **Plan**, or `/task <request>` to start it as a
+   task for the team. Follow the agents in **Lobby** and **Tasks**; their steps fold into one line in
+   the conversation and open in place.
+
+`/bot-lobby <request>` in Pi also starts a task. `--fast` / `--full` picks the workflow, and
+`--branch` / `--worktree` isolates it in git. Workers never commit: the oracle commits only the
 files the task changed, after the project's linter and a QA pass sized to the change's risk.
 
 ## The lobby
 
-- **Lobby**: the conversation with the oracle, each run of agent steps inline, and **Thinking** for
-  their reasoning.
+- **Lobby**: the team chat. The oracle and the agents answer here, each reply under its agent's
+  name; each run of agent steps shows inline, and **Thinking** holds their reasoning. Typing `@` or
+  `/` at the start of a message opens a list of agents or commands to pick from.
 - **Plan**: plan with a panel of agents. **View plan** (`V`) opens the draft in a slide-out, where
   any line takes a comment.
 - **Tasks**: every task across sessions as a list or a board, with its steps, timings and **Resume**.
@@ -48,7 +54,7 @@ Git opens pull requests at `#/git` and `#/git/<number>`, and issues at `#/git/is
 addresses fall back to Lobby; Excalidraw integration is removed without deleting saved room links
 or external boards.
 
-The composer appears only on **Lobby**, **Tasks**, **Plan**, **Quick fix** and **Knowledge**, including
+The composer appears only on **Lobby**, **Tasks**, **Plan** and **Knowledge**, including
 supported detail routes and Knowledge's Docs/Chat views. On Git, Metrics and Settings it stays mounted
 but hidden and inert, preserving drafts and attachments (including uploads that finish while hidden)
 without taking space.

package/THIRD_PARTY_NOTICES.md

@@ -36,6 +36,7 @@ naming the file it came from.
 | `webui/src/components/reui/popover.tsx` | `apps/web/src/components/ui/popover.tsx` |
 | `webui/src/app/Sidebar.tsx` | `apps/web/src/components/Sidebar.tsx`, `apps/web/src/components/ui/sidebar.tsx` |
 | `webui/src/app/Composer.tsx` | `apps/web/src/components/chat/ComposerSurface.tsx`, `ChatComposer.tsx`, `ComposerPrimaryActions.tsx`, `ComposerControl.tsx` |
+| `webui/src/app/composer/ComposerCommandMenu.tsx` | `apps/web/src/components/chat/ComposerCommandMenu.tsx`, `ComposerBanner.tsx` (the attached drawer surface), `composer-logic.ts` (the `/` and `@` trigger) |
 | `webui/src/app/TerminalDrawer.tsx` | `apps/web/src/components/ThreadTerminalDrawer.tsx` (the drawer, its floating toolbar and terminal list) |
 | `webui/src/tabs/lobby/InlineActivity.tsx` | `apps/web/src/components/chat/WorkLog.tsx` |
 | `src/webui/palette-core.ts` (the built-in themes) | `packages/shared/src/themePalettes.ts` (Blossom is their T3 Chat theme, renamed) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.57",
+  "version": "0.6.58",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/lobby-chat.md

@@ -0,0 +1,39 @@
+# Lobby Chat
+
+You are answering the user directly in Bot Lobby's chat. There is no task,
+brief, plan or review round here: the user talks to the team the way they
+would talk to a colleague, and this message was given to you because it is
+yours to answer (they named you with an @ mention, or the classifier judged
+it your area). The Master (the oracle) and the other agents share this chat
+and read your reply.
+
+## How to work
+
+- Read **Conversation so far** for context, then answer the **Message**. A
+  question gets an answer; a request for a change gets the change.
+- Read only what you need, and follow the code's existing conventions. When
+  the message ends with **Likely files**, start there (and use
+  `find_relevant_files`, when you have it, before a broad search).
+- When you need several reads or searches that do not depend on each other,
+  make them all in one turn: they run in parallel.
+- Changes (when you may edit): make the smallest correct change that does
+  what was asked, with `edit`/`write`, never shell redirection or `sed -i`.
+  Do not refactor, rename or tidy anything else. Run a quick targeted check
+  when one exists (the nearest test, a typecheck) with a bash `timeout`;
+  never start dev servers, watchers or background processes. Do not commit
+  unless the user asks.
+- If the message is ambiguous, take the most reasonable reading and say which
+  one you chose; do not stop to ask.
+- If the work turns out large (many areas, a new dependency, an architecture
+  change, a decision only the user can make), do not start it: say what it
+  would take, and suggest `/plan` to plan it with the panel or `/task` to hand
+  it to the team.
+- A bot-lobby task may be running in this working tree at the same time:
+  touch only the files the message needs, re-read a file right before you
+  edit it, and never revert changes you did not make.
+
+## Your reply
+
+Write to the user, in plain prose and Markdown, as short as the answer
+allows: no report headings, no brief check. When you changed files, end with
+a short list of them and what you ran to check, or say it was not checked.

package/prompts/master.md

@@ -460,12 +460,12 @@ nothing.
 
 Not every change in the tree is this task's. Worker and QA reports end with
 who changed each file, from bot-lobby's record of every agent's edits:
-**planned** (this task's workers), **quick fix** (the user's own direct
-requests from the lobby: authorised, so never revert them or send them back as
-fixes), **pre-existing** and **another task** (not this task's), and
+**planned** (this task's workers), **lobby chat** (changes the user asked
+for directly in the lobby chat: authorised, so never revert them or send them
+back as fixes), **pre-existing** and **another task** (not this task's), and
 **unattributed** (no agent recorded it: ask the user before counting it in or
-reverting it). A QA finding about a quick fix is yours to act on only when it
-breaks this task.
+reverting it). A QA finding about a lobby chat change is yours to act on only
+when it breaks this task.
 
 ## Completion
 
@@ -485,8 +485,8 @@ because a Worker says it is done.
 You commit your agents' work, not they: workers never commit. Call
 `action=complete` with `message`, a commit message you write from what was
 built, and the engine commits exactly the files this task's workers changed
-(never ones that held changes before they started, a quick fix's alone, or
-another task's) before calling the task done. Keep it concise: a first line of
+(never ones that held changes before they started, the lobby chat's alone,
+or another task's) before calling the task done. Keep it concise: a first line of
 72 characters or fewer saying what changed, in the imperative ("Add login
 rate limit"), and at most three short lines below it when the why is not
 obvious. No file lists, step-by-step narration, test counts or sign-offs. A

package/prompts/reviewer.md

@@ -37,18 +37,18 @@ Verification (`- engine lint on the touched files — no new problems`).
 
 ## Change provenance
 
-The working tree can hold changes that are not this task's: the user makes
-quick fixes from the lobby while tasks run, other tasks may run beside this
+The working tree can hold changes that are not this task's: the user asks for
+changes in the lobby chat while tasks run, other tasks may run beside this
 one, and there may have been uncommitted work before the task started. When
 your context lists who changed each file (bot-lobby's own record of every
 agent's `edit`/`write` calls), judge each change by its source:
 
 - **planned**: this task's workers. Review it against the plan, scope
   discipline included.
-- **quick fix**: a change the user asked for directly. It is authorised and
-  outside this task's plan, so it is never scope creep or a rogue change, and
-  you never ask for it to be reverted. Mention it only if it breaks this task
-  or its checks, naming the quick fix.
+- **lobby chat**: a change the user asked for directly in the lobby chat. It
+  is authorised and outside this task's plan, so it is never scope creep or a
+  rogue change, and you never ask for it to be reverted. Mention it only if it
+  breaks this task or its checks, naming the chat reply (`CHAT-3`).
 - **another task** or **pre-existing**: not this task's work. Leave it alone
   unless it breaks this task.
 - **unattributed**: no agent recorded the edit (the user by hand, a shell

package/src/classifier/instance.ts

@@ -70,7 +70,7 @@ export function knowledgeFor(): KnowledgePicker {
   return { ...knowledgePicker(classifier(), log), scripts: scriptPicker(classifier(), log) };
 }
 
-/** Shared scripts for a quick fix, with what Jev matched logged to the lobby's activity feed. */
+/** Shared scripts for a lobby chat agent, with what Jev matched logged to the lobby's activity feed. */
 export function scriptsPickerFor(): ScriptPicker {
   return scriptPicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }

package/src/classifier/lobby.ts

@@ -0,0 +1,37 @@
+/**
+ * Who answers a lobby chat message: the classifier reads the message (with
+ * the last few lines of the conversation) and picks the agent whose area it
+ * is, so a frontend question goes to DESIGN, a library question to RESEARCH,
+ * "how does this work" to a scout and a question about the project's saved
+ * knowledge to the oracle's knowledge lookup. Anything it is unsure of, and
+ * every message while it is off, goes to the Master.
+ */
+import type { ChatAgent } from "../lobby/prompts.ts";
+import type { Classifier } from "./classifier.ts";
+import { choice, choiceOf } from "./client.ts";
+import { clip } from "./limits.ts";
+
+/** Where a lobby message goes: an agent, or the oracle's knowledge lookup. */
+export type ChatRoute = ChatAgent | "knowledge";
+
+const ROUTES: Record<ChatRoute, string> = {
+  master: "The Master (the oracle): general conversation, the team's tasks and plans, anything across several areas of the project, or anything no single agent below clearly owns",
+  designer: "DESIGN: the frontend, meaning pages, components, styling, layout, UX, on-screen copy and browser code, whether a question about it or a change to it",
+  backend: "DEV: backend code, meaning APIs, data and databases, server logic, integrations, scripts, build and tooling, whether a question about it or a change to it",
+  qa: "QA: tests, meaning writing, running or fixing them, test strategy, how to verify a change, or checking work for bugs",
+  researcher: "RESEARCH: facts from outside the repository, meaning libraries, versions, third-party APIs, documentation, standards, or comparing tools",
+  scout: "SCOUT: understanding the existing code without changing it, meaning where something lives, how a part works, or tracing a flow through the code",
+  knowledge: "KNOWLEDGE: what the project's saved knowledge says, meaning its conventions, standards, past decisions and architecture notes",
+};
+
+/** The agent the classifier picks for `message`, when it is on and sure enough; undefined leaves it to the Master. */
+export async function routeChatMessage(classifier: Classifier, message: string, recent: readonly string[], options: { at: number; signal?: AbortSignal }): Promise<{ route: ChatRoute; probability: number } | undefined> {
+  if (!classifier.enabled("lobby") || !message.trim()) return undefined;
+  const result = await classifier.ask("lobby", {
+    state: { message: clip(message, 4000), ...(recent.length > 0 ? { recent_conversation: clip(recent.join("\n"), 2000) } : {}) },
+    questions: { agent: choice("Which member of a software team should answer `message`, which the user typed into the team's chat? Read `recent_conversation`, when present, for what the message refers to.", ROUTES) },
+  }, options.signal ? { signal: options.signal } : {});
+  const picked = choiceOf(result?.answers, "agent");
+  if (!picked || !(picked.choice in ROUTES) || picked.probability < options.at) return undefined;
+  return { route: picked.choice as ChatRoute, probability: picked.probability };
+}

package/src/classifier/triage.ts

@@ -3,8 +3,7 @@
  * size, which domains it touches, whether it needs outside facts or a
  * clarifying question, and what kind of work it is — in one call. The Master
  * reads the answers as hints (so it can skip reasoning them out and skip
- * scouts it does not need); nothing here becomes a workflow rule. The same
- * size question holds back a quick fix that is really a task, and a clarify
+ * scouts it does not need); nothing here becomes a workflow rule. A clarify
  * question whose recommended option is clearly right is answered here.
  */
 import type { Domain } from "../schemas/agent.ts";
@@ -48,7 +47,7 @@ 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. */
+/** Whether one agent can just do it, or it needs the team: a self-contained build takes the fast track. */
 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?`,
@@ -143,27 +142,6 @@ export async function triageWithContext(classifier: Classifier, scope: FileScope
   return files.length > 0 ? { ...triage, likelyFiles: files } : triage;
 }
 
-/**
- * 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 { 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 && (yesOf(answers, "solo") ?? 0) < quickFixAt ? 1 : 0;
-    },
-  });
-  const size = scoreOf(result?.answers, "size");
-  if (!size) return undefined;
-  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;
 
 /** The one-line path the triage suggests to the Master. */

package/src/execution/delegation.ts

@@ -43,9 +43,9 @@ export function canDelegate(agent: { role: Role; domain: Domain; depth?: number
   return agent.role === "reviewer" && agent.domain === "qa";
 }
 
-/** A task's DESIGN/DEV workers (not their children, nor quick fixes) may consult a stronger model, when the setting is on. */
+/** A task's DESIGN/DEV workers (not their children, nor lobby chat agents) may consult a stronger model, when the setting is on. */
 export function canConsult(agent: { runId: string; taskId: string; role: Role; domain: Domain; depth?: number }, enabled: boolean): boolean {
-  // A lobby job (a quick fix) runs as its own task: it is one agent on a small change, not a task's worker.
+  // A lobby chat agent runs as its own task: it is one agent answering the user, not a task's worker.
   return enabled && agent.taskId !== agent.runId && (agent.depth ?? 1) === 1 && agent.role === "worker" && (agent.domain === "designer" || agent.domain === "backend");
 }
 

package/src/index.ts

@@ -4,7 +4,6 @@ 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 { releaseAttachments } from "./state/attachments.ts";
 import { detectProjectRoot } from "./state/project.ts";
@@ -46,8 +45,6 @@ export default function (pi: ExtensionAPI): void {
   });
   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, undefined, CONFIG_DIR_NAME);
   // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).

package/src/lobby/chat-agents.ts

@@ -0,0 +1,293 @@
+/**
+ * The lobby chat's agents: a message the classifier (or an @ mention) gives
+ * to DESIGN, DEV, QA, RESEARCH or a scout is answered by that agent itself,
+ * on its own model, thinking, prompt and grants, with the conversation so
+ * far as context. The builders may change files; RESEARCH and the scout only
+ * read. Replies run one at a time in the order they were asked, so two agents
+ * never edit the tree at once; each streams plain-words steps into the
+ * activity feed, its reply joins the conversation under its name, and every
+ * finished reply lands in the metrics log. The Master's own replies are pi's
+ * turns, not this queue's.
+ */
+import { loadPrompt } from "../prompts/loader.ts";
+import { compilePrompt } from "../prompts/compiler.ts";
+import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
+import { MAX_CHILDREN } from "../execution/delegation.ts";
+import { describeToolCall } from "../pi/activity.ts";
+import { appendMetrics, type MetricRecord, type MetricStatus } from "../state/metrics.ts";
+import { appendChange, EditLog } from "../state/changes.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import type { Domain, Role } from "../schemas/agent.ts";
+import type { LobbyFeed } from "./feed.ts";
+import type { LobbyRunProfile } from "./profile.ts";
+import { CHAT_AGENT_SOURCES, type ChatAgent } from "./prompts.ts";
+import { PLANNER_TOOLS, RESEARCH_PANEL_TOOLS } from "./planner.ts";
+
+/** The agents this queue runs: every chat agent but the Master. */
+export type ChatWorker = Exclude<ChatAgent, "master">;
+
+/** DESIGN, DEV and QA may change files; RESEARCH and the scout only read. */
+export const CHAT_BUILDER_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+
+const TOOLS: Record<ChatWorker, readonly string[]> = {
+  designer: CHAT_BUILDER_TOOLS,
+  backend: CHAT_BUILDER_TOOLS,
+  qa: CHAT_BUILDER_TOOLS,
+  researcher: RESEARCH_PANEL_TOOLS,
+  scout: PLANNER_TOOLS,
+};
+
+/** What each agent owns, appended to its prompt. */
+const SEATS: Record<ChatWorker, string> = {
+  designer: "You are DESIGN: the frontend and the user's experience — pages, components, styling, layout, states, copy on screen, accessibility and everything that runs in the browser.",
+  backend: "You are DEV: the backend and the code — APIs, data and migrations, server logic, integrations, errors and edge cases, security, performance, build and tooling.",
+  qa: "You are QA: tests and how work is judged — writing, running and fixing tests, the test strategy, edge cases and failure modes, and checking a change for bugs.",
+  researcher: "You are RESEARCH: facts outside the repository — libraries and versions, standards, APIs and documentation, known pitfalls and prior art. Use the web tools when you have them and cite a URL for every external claim. You never change files.",
+  scout: "You are a SCOUT: you read the repository to answer how it works — where things live, how a part fits together, what calls what — citing paths and symbols. You never change files.",
+};
+
+const DOMAIN_OF: Record<ChatWorker, Domain> = { designer: "designer", backend: "backend", qa: "qa", researcher: "backend", scout: "backend" };
+const ROLE_OF: Record<ChatWorker, Role> = { designer: "worker", backend: "worker", qa: "worker", researcher: "researcher", scout: "scout" };
+
+/** Lines of conversation an agent is given, newest last. */
+export const CHAT_CONTEXT_LINES = 12;
+/** Longest line of earlier conversation it is given. */
+const CONTEXT_LINE_CHARS = 1200;
+export const MAX_CHAT_JOBS = 30;
+
+export type ChatJobStatus = "queued" | "running" | "success" | "failed" | "cancelled" | "timeout";
+
+export interface ChatJob {
+  id: string;
+  agent: ChatWorker;
+  /** The user's message, as they sent it (without the @ mention). */
+  text: string;
+  /** Why it came to this agent: `you named @design`, `the classifier (0.82)`. */
+  why: string;
+  status: ChatJobStatus;
+  createdAt: number;
+  startedAt?: number;
+  finishedAt?: number;
+  model?: string;
+  thinking?: string;
+  tools: number;
+  reply?: string;
+  error?: string;
+  /** Files it changed, as shown (relative to the project). */
+  files?: string[];
+  usage?: { input: number; output: number; cost: number; turns: number };
+}
+
+export interface ChatAgentsDeps {
+  cwd: string;
+  root: string;
+  configDir: string;
+  /** Model, thinking and grants for an agent, read from settings when its reply starts. */
+  profile: (agent: ChatWorker) => LobbyRunProfile;
+  /** The conversation so far, oldest first, as lines (`You: …`, `DESIGN: …`). */
+  history: () => readonly string[];
+  /** A reply is done: put it in the conversation (and the session, so the Master reads it too). */
+  onReply?: (job: ChatJob) => void;
+  onChange?: () => void;
+  feed?: LobbyFeed;
+  /** Likely files for the message, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  stallTimeoutMs?: number;
+  toolStallTimeoutMs?: number;
+  runProcess?: ProcessRunner;
+}
+
+/** An agent's system prompt: its domain's layers (the global one for RESEARCH and scouts), the lobby chat role and its seat. */
+export function chatAgentPrompt(agent: ChatWorker, instructions?: string): string {
+  const custom = instructions?.trim();
+  const base = agent === "researcher" || agent === "scout"
+    ? [loadPrompt("global.md"), custom ? `## Custom Instructions\n\n${custom}` : ""].filter(Boolean).join("\n\n---\n\n")
+    : compilePrompt({ domain: agent, task: "", ...(custom ? { instructions: custom } : {}) });
+  return [base, loadPrompt("lobby-chat.md"), `## Your seat\n\n${SEATS[agent]}`].join("\n\n---\n\n");
+}
+
+/** What the agent is asked: the conversation so far, then the message. */
+export function chatAgentTask(text: string, history: readonly string[], likely = ""): string {
+  const lines = history.slice(-CHAT_CONTEXT_LINES).map((line) => (line.length > CONTEXT_LINE_CHARS ? `${line.slice(0, CONTEXT_LINE_CHARS - 1)}…` : line));
+  return [
+    lines.length > 0 ? `## Conversation so far\n\n${lines.join("\n\n")}` : "",
+    `## Message\n\n${text.trim()}`,
+    likely,
+  ].filter(Boolean).join("\n\n");
+}
+
+function isActive(job: ChatJob): boolean {
+  return job.status === "queued" || job.status === "running";
+}
+
+export class ChatAgents {
+  jobs: ChatJob[] = [];
+  private readonly deps: ChatAgentsDeps;
+  private readonly controllers = new Map<string, AbortController>();
+  private readonly edits = new Map<string, EditLog>();
+  private counter = 0;
+
+  constructor(deps: ChatAgentsDeps) {
+    this.deps = deps;
+  }
+
+  get running(): ChatJob | undefined {
+    return this.jobs.find((job) => job.status === "running");
+  }
+
+  /** Any reply under way or waiting. */
+  get busy(): boolean {
+    return this.jobs.some(isActive);
+  }
+
+  /** Ask an agent; it answers at once when no other reply is under way, else after the ones before it. */
+  submit(agent: ChatWorker, text: string, why: string, now = Date.now()): ChatJob {
+    const body = text.trim();
+    if (!body) throw new Error("a message needs some text");
+    const job: ChatJob = { id: `CHAT-${++this.counter}`, agent, text: body, why, status: "queued", createdAt: now, tools: 0 };
+    this.jobs = [...this.jobs, job].filter((entry, index, all) => isActive(entry) || index >= all.length - MAX_CHAT_JOBS);
+    this.changed();
+    this.pump();
+    return job;
+  }
+
+  /** Stop the reply under way and drop the waiting ones. */
+  cancelAll(): void {
+    const now = Date.now();
+    for (const job of this.jobs) {
+      if (job.status !== "queued") continue;
+      job.status = "cancelled";
+      job.finishedAt = now;
+    }
+    for (const controller of this.controllers.values()) controller.abort();
+    this.changed();
+  }
+
+  private changed(): void {
+    this.deps.onChange?.();
+  }
+
+  private pump(): void {
+    if (this.running) return;
+    const next = this.jobs.find((job) => job.status === "queued");
+    if (next) void this.run(next);
+  }
+
+  private onEvent(job: ChatJob, event: PiStreamEvent): void {
+    const source = CHAT_AGENT_SOURCES[job.agent];
+    const now = Date.now();
+    if (event.type === "tool_execution_start") {
+      job.tools += 1;
+      const edits = this.edits.get(job.id);
+      if (edits?.note(event.toolName, event.args)) job.files = edits.shown();
+      this.deps.feed?.step(source, describeToolCall(event.toolName, event.args), job.id, now);
+    } else if (event.type === "thought") this.deps.feed?.liveThought(source, event.text, job.id, now);
+    else if (event.type === "retry") this.deps.feed?.step(source, `provider retry ${event.attempt}/${event.maxAttempts}`, job.id, now);
+    else return;
+    this.changed();
+  }
+
+  private async run(job: ChatJob): Promise<void> {
+    const profile = this.deps.profile(job.agent);
+    const controller = new AbortController();
+    this.controllers.set(job.id, controller);
+    job.status = "running";
+    job.startedAt = Date.now();
+    job.thinking = profile.thinking;
+    if (profile.model) job.model = profile.model;
+    this.edits.set(job.id, new EditLog(this.deps.cwd));
+    this.changed();
+    // The message itself is the last line of the history; the task names it on its own.
+    const history = this.deps.history();
+    const earlier = history.at(-1)?.endsWith(job.text) ? history.slice(0, -1) : history;
+    try {
+      const likely = await this.likely(job.text, controller.signal);
+      const result = await runPiAgent(
+        {
+          cwd: this.deps.cwd,
+          task: chatAgentTask(job.text, earlier, likely),
+          systemPrompt: chatAgentPrompt(job.agent, profile.instructions),
+          tools: [...TOOLS[job.agent], ...(this.deps.hints?.tools() ?? [])],
+          model: profile.model,
+          thinking: profile.thinking,
+          mcpTools: profile.mcpTools,
+          ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+          ...(profile.compactAt ? { compactAt: profile.compactAt } : {}),
+          ...(profile.harness ? { harness: profile.harness } : {}),
+          ...(profile.skills ? { skills: profile.skills } : {}),
+          delegationQuota: { used: MAX_CHILDREN },
+          agent: { runId: job.id, taskId: job.id, domain: DOMAIN_OF[job.agent], role: ROLE_OF[job.agent] },
+          signal: controller.signal,
+          stallTimeoutMs: this.deps.stallTimeoutMs,
+          toolStallTimeoutMs: this.deps.toolStallTimeoutMs,
+          onEvent: (event) => this.onEvent(job, event),
+        },
+        this.deps.runProcess ?? spawnPiProcess,
+      );
+      job.status = result.status;
+      job.reply = result.output.trim() || undefined;
+      job.error = result.error;
+      job.usage = result.usage;
+      if (result.model) job.model = result.model;
+    } catch (error) {
+      job.status = "failed";
+      job.error = (error as Error).message;
+    } finally {
+      this.controllers.delete(job.id);
+      this.finish(job);
+    }
+  }
+
+  /** The Likely files block for a message, or "" (no hints, nothing stands out, out of time). */
+  private async likely(text: string, signal: AbortSignal): Promise<string> {
+    try {
+      return (await this.deps.hints?.block(text, signal)) ?? "";
+    } catch {
+      return "";
+    }
+  }
+
+  private finish(job: ChatJob): void {
+    job.finishedAt = Date.now();
+    const source = CHAT_AGENT_SOURCES[job.agent];
+    const edited = this.edits.get(job.id)?.list() ?? [];
+    this.edits.delete(job.id);
+    // What it edited, even when it failed, is on record for a task's QA gate as the user's own request.
+    if (edited.length > 0) {
+      appendChange(this.deps.root, this.deps.configDir, {
+        source: "chat",
+        id: job.id,
+        what: `${source}: ${job.text.split("\n").find((line) => line.trim())?.trim() ?? ""}`,
+        files: edited,
+        startedAt: new Date(job.startedAt ?? job.createdAt).toISOString(),
+        finishedAt: new Date(job.finishedAt).toISOString(),
+        status: job.status,
+      });
+    }
+    this.deps.feed?.end(job.id, job.status !== "success");
+    this.deps.feed?.settleThought(job.id);
+    if (job.status !== "success") this.deps.feed?.log(source, `reply ${job.status}${job.error ? ` — ${job.error.split("\n")[0]}` : ""}`, job.status === "cancelled" ? "warning" : "error", job.finishedAt);
+    appendMetrics(this.deps.root, this.deps.configDir, [chatMetric(job)]);
+    this.deps.onReply?.(job);
+    this.changed();
+    this.pump();
+  }
+}
+
+export function chatMetric(job: ChatJob): MetricRecord {
+  const started = job.startedAt ?? job.createdAt;
+  const status: MetricStatus = job.status === "queued" || job.status === "running" ? "failed" : job.status;
+  return {
+    id: `${job.id}-${started}`,
+    kind: "chat",
+    agent: CHAT_AGENT_SOURCES[job.agent],
+    ...(job.model ? { model: job.model } : {}),
+    ...(job.thinking ? { thinking: job.thinking } : {}),
+    status,
+    startedAt: new Date(started).toISOString(),
+    durationMs: Math.max(0, (job.finishedAt ?? started) - started),
+    ...(job.usage?.turns ? { turns: job.usage.turns } : {}),
+    tools: job.tools,
+    ...(job.usage ? { input: job.usage.input, output: job.usage.output, cost: job.usage.cost } : {}),
+  };
+}