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

package/src/pi/start-task.ts

@@ -32,9 +32,6 @@ function uniqueTaskId(root: string, configDir: string, request: string): string
   return id;
 }
 
-/** 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");
@@ -74,14 +71,13 @@ function plannedSteps(task: Task): string[] {
   ].filter(Boolean);
 }
 
-export function kickoff(task: Task, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
+export function kickoff(task: Task, options: { fastTrack?: 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)] : []),
     ...(task.git ? [gitLine(task.git)] : []),
     "",
@@ -135,11 +131,9 @@ export interface StartOptions {
   title?: string;
   /** 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. */
+  /** The classifier already read the request: `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;
   /** `--branch`, `--worktree` or `--no-branch`: whether this task gets a git branch or worktree of its own; `workflow.gitIsolation` when absent. */
   isolation?: GitIsolation;
 }
@@ -182,7 +176,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, { fastTrack: config.workflow.fastTrack, ...(options.routed ? { routed: true } : {}) }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  pi.sendUserMessage(kickoff(task, { fastTrack: config.workflow.fastTrack }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;
 }
 

package/src/pi/switch.ts

@@ -5,7 +5,7 @@
  * that is still under way (a resumed session picks its task back up).
  * Ctrl+Shift+M and `/bot-lobby on|off` switch it; starting a task, opening the
  * web lobby or answering a task's proposal turns it on. Off stops the web
- * lobby too, and anything it runs (a quick fix, a review, a planning round)
+ * lobby too, and anything it runs (a chat agent's reply, a review, a planning round)
  * stops with it, so the user is asked first when something is running.
  */
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";

package/src/schemas/configuration.ts

@@ -53,11 +53,11 @@ export interface ScoutConfig extends HarnessChoice {
 }
 
 /** Subagent kinds with their own settings entry. */
-export const SUBAGENT_KINDS = ["designer", "backend", "qa", "scout", "researcher", "quickfix", "planner"] as const;
+export const SUBAGENT_KINDS = ["designer", "backend", "qa", "scout", "researcher", "planner"] as const;
 export type SubagentKind = (typeof SUBAGENT_KINDS)[number];
 
-/** Lobby agents that run outside the workflow: direct quick fixes and the task planner. */
-export type LobbyAgentKind = "quickfix" | "planner";
+/** Lobby agents that run outside the workflow and have their own settings entry: the task planner. */
+export type LobbyAgentKind = "planner";
 
 /** Settings kinds a workflow run (domain + role) can draw from. */
 export type WorkflowProfileKind = Domain | "scout" | "researcher";
@@ -94,11 +94,9 @@ export interface WorkflowConfig {
   fastTrack: boolean;
   /** A delegation that names nothing concrete, or is long without done criteria, is sent back to the oracle once for a fuller brief (sending it again unchanged goes through). */
   briefCheck: 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;
   /** A new task gets a git branch or worktree of its own, named after it; `--branch` and `--worktree` decide for one task. */
   gitIsolation: GitIsolation;
-  /** Scouts, workers, quick fixes and the planner get the repository map: the layout and the files matching their step, with each file's purpose, names and unchanged scout notes. */
+  /** Scouts, workers, lobby chat replies and the planner get the repository map: the layout and the files matching their step, with each file's purpose, names and unchanged scout notes. */
   repoMap: boolean;
   /** A scout asked the same thing again for the same task, on a tree that has not changed, reuses its findings instead of running. */
   reuseScouts: boolean;
@@ -202,7 +200,7 @@ export interface LobbyConfig {
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "scripts", "qa"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "scripts", "qa", "lobby"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -229,10 +227,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;
+  /** A lobby message goes to the agent the classifier picks for it at least this likely; below it, the Master answers. */
+  lobbyAgentAt: number;
 }
 
 /** The classifier: a fast model for obvious decisions, so large models spend fewer tokens on them. */
@@ -266,8 +262,6 @@ export interface BotLobbyConfig {
   agents: Record<"designer" | "backend" | "qa", AgentModelConfig>;
   scout: ScoutConfig;
   researcher: AgentModelConfig;
-  /** Direct quick fixes from the lobby: no scouting, planning or review. */
-  quickFix: AgentModelConfig;
   /** The task planner that grills the user until a plan is clear. */
   planner: AgentModelConfig;
   workflow: WorkflowConfig;
@@ -289,7 +283,6 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
   },
   scout: { model: INHERIT_MODEL, maxToolCalls: 30 },
   researcher: { model: INHERIT_MODEL, thinking: "low", instructions: "" },
-  quickFix: { model: INHERIT_MODEL, thinking: "low", instructions: "" },
   planner: { model: INHERIT_MODEL, thinking: "high", instructions: "" },
   workflow: {
     maxReviewIterations: 2,
@@ -304,7 +297,6 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     freshContext: true,
     fastTrack: true,
     briefCheck: true,
-    routeQuickFixes: true,
     gitIsolation: "off",
     repoMap: true,
     reuseScouts: true,
@@ -338,7 +330,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, scripts: true, qa: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, scripts: true, qa: true, lobby: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,
@@ -349,8 +341,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
       scriptRelevantAt: 0.5,
       simpleAt: 0.7,
       trivialAt: 0.8,
-      quickFixAt: 0.7,
-      quickFixLargeAt: 0.8,
+      lobbyAgentAt: 0.5,
     },
     fileHints: { topK: 8, maxCandidates: 480, budgetMs: 1500 },
     effort: { cheapModel: INHERIT_MODEL },
@@ -536,7 +527,6 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   workflow.freshContext = workflow.freshContext !== false;
   workflow.fastTrack = workflow.fastTrack !== false;
   workflow.briefCheck = workflow.briefCheck !== false;
-  workflow.routeQuickFixes = workflow.routeQuickFixes !== false;
   workflow.repoMap = workflow.repoMap !== false;
   workflow.reuseScouts = workflow.reuseScouts !== false;
   workflow.parallelMode = isParallelMode(workflow.parallelMode) ? workflow.parallelMode : DEFAULT_CONFIG.workflow.parallelMode;
@@ -546,7 +536,8 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   workflow.expertModel = typeof workflow.expertModel === "string" ? workflow.expertModel.trim() : "";
   workflow.gitIsolation = isGitIsolation(workflow.gitIsolation) ? workflow.gitIsolation : DEFAULT_CONFIG.workflow.gitIsolation;
   // Agent time limits are gone: a config file that still names them is cleaned on its next save.
-  for (const key of ["agentTimeoutMs", "wrapUpAt", "taskBudgetMinutes"]) delete (workflow as unknown as Record<string, unknown>)[key];
+  // So are quick fixes: the lobby chat does that work now.
+  for (const key of ["agentTimeoutMs", "wrapUpAt", "taskBudgetMinutes", "routeQuickFixes"]) delete (workflow as unknown as Record<string, unknown>)[key];
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };
   const srcAgents = (src.agents ?? {}) as Partial<BotLobbyConfig["agents"]>;
   return {
@@ -558,7 +549,6 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
     },
     scout: normalizeScout(src.scout as Partial<ScoutConfig> | undefined),
     researcher: normalizeAgent(DEFAULT_CONFIG.researcher, src.researcher as Partial<AgentModelConfig> | undefined),
-    quickFix: normalizeAgent(DEFAULT_CONFIG.quickFix, src.quickFix as Partial<AgentModelConfig> | undefined),
     planner: normalizeAgent(DEFAULT_CONFIG.planner, src.planner as Partial<AgentModelConfig> | undefined, false),
     workflow,
     lint: normalizeLint(src.lint),
@@ -636,9 +626,9 @@ export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role)
   return { kind, model: modelOf(entry.model), thinking: entry.thinking, instructions, ...grantFields(entry), ...compactField(entry), ...harnessField(config, entry) };
 }
 
-/** The settings entry of a lobby agent (quick fix or planner). */
-export function lobbyAgentConfig(config: BotLobbyConfig, kind: LobbyAgentKind): AgentModelConfig {
-  return kind === "quickfix" ? config.quickFix : config.planner;
+/** The settings entry of a lobby agent (the planner). */
+export function lobbyAgentConfig(config: BotLobbyConfig, _kind: LobbyAgentKind): AgentModelConfig {
+  return config.planner;
 }
 
 /** Profile for a lobby agent run, from settings alone; `model` is undefined while unset. */

package/src/state/changes.ts

@@ -1,8 +1,9 @@
 /**
- * Who changed what: a project-wide ledger of the files each quick fix and each
- * task worker edited, read from their own `edit`/`write` tool calls (never
- * from their reports). The QA gate and the Master see every changed file of
- * the working tree against it, so a quick fix the user asked for, a planned
+ * Who changed what: a project-wide ledger of the files each lobby chat reply
+ * and each task worker edited, read from their own `edit`/`write` tool calls
+ * (never from their reports). The QA gate and the Master see every changed
+ * file of the working tree against it, so a change the user asked for in the
+ * lobby chat, a planned
  * step, work that was there before the task and an edit no agent made each
  * read as what they are, instead of all looking like unplanned changes.
  * Append-only JSON lines beside the metrics; best-effort like them.
@@ -13,11 +14,12 @@ import type { Domain } from "../schemas/agent.ts";
 import type { Task } from "../schemas/task.ts";
 import { dataRoot } from "./project.ts";
 
-export type ChangeSource = "quickfix" | "worker";
+/** `chat`: an agent answering the user in the lobby chat (older ledgers call it `quickfix`). */
+export type ChangeSource = "chat" | "worker";
 
 export interface ChangeRecord {
   source: ChangeSource;
-  /** The quick fix (`QF-3`) or the worker run that made the edits. */
+  /** The chat reply (`CHAT-3`) or the worker run that made the edits. */
   id: string;
   /** The task a worker ran for. */
   taskId?: string;
@@ -106,7 +108,7 @@ export function appendChange(root: string, configDir: string, record: ChangeReco
 function isRecord(value: unknown): value is ChangeRecord {
   if (!value || typeof value !== "object") return false;
   const record = value as Partial<ChangeRecord>;
-  return (record.source === "quickfix" || record.source === "worker") && typeof record.id === "string" && Array.isArray(record.files) && typeof record.finishedAt === "string";
+  return (record.source === "chat" || record.source === "worker" || (record.source as unknown) === "quickfix") && typeof record.id === "string" && Array.isArray(record.files) && typeof record.finishedAt === "string";
 }
 
 /** Every record in the ledger finished at or after `since` (ISO), oldest first. */
@@ -123,7 +125,7 @@ export function readChanges(root: string, configDir: string, since?: string): Ch
     if (!line.trim()) continue;
     try {
       const record: unknown = JSON.parse(line);
-      if (isRecord(record) && Date.parse(record.finishedAt) >= from) records.push(record);
+      if (isRecord(record) && Date.parse(record.finishedAt) >= from) records.push((record.source as unknown) === "quickfix" ? { ...record, source: "chat" } : record);
     } catch {
       // A torn line (a crash mid-append) is skipped.
     }
@@ -131,7 +133,7 @@ export function readChanges(root: string, configDir: string, since?: string): Ch
   return records;
 }
 
-export type Provenance = "planned" | "quickfix" | "other-task" | "pre-existing" | "unattributed";
+export type Provenance = "planned" | "chat" | "other-task" | "pre-existing" | "unattributed";
 
 export interface FileProvenance {
   /** Repository-relative, as git reports it. */
@@ -140,8 +142,8 @@ export interface FileProvenance {
   kinds: Provenance[];
   /** One clause per source: `planned: DEV — Add the login endpoint`. */
   notes: string[];
-  /** The quick fixes that edited it. */
-  quickFixes: string[];
+  /** The lobby chat replies that edited it. */
+  chats: string[];
   /** This task's domains whose workers edited it. */
   domains?: Domain[];
 }
@@ -161,7 +163,7 @@ function clock(iso: string): string {
 /**
  * Explain each changed file of the working tree (`changed`, relative to the
  * repository at `top`) for `task`: edits by its own workers are planned; by a
- * quick fix, the user's direct request; by another task's workers, that
+ * lobby chat reply, the user's direct request; by another task's workers, that
  * task's; changed before its agents started, pre-existing; anything else, no
  * agent recorded it. `records` should reach back to the task's start.
  */
@@ -181,16 +183,16 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
   return changed.map((path) => {
     const kinds: Provenance[] = [];
     const notes: string[] = [];
-    const quickFixes: string[] = [];
+    const chats: string[] = [];
     const domains: Domain[] = [];
     const add = (kind: Provenance, note: string) => {
       if (!kinds.includes(kind)) kinds.push(kind);
       if (!notes.includes(note)) notes.push(note);
     };
     for (const record of byFile.get(path) ?? []) {
-      if (record.source === "quickfix") {
-        add("quickfix", `quick fix ${record.id}${clock(record.finishedAt)}, asked by the user: "${clip(record.what)}"`);
-        if (!quickFixes.includes(record.id)) quickFixes.push(record.id);
+      if (record.source === "chat") {
+        add("chat", `lobby chat ${record.id}${clock(record.finishedAt)}, asked by the user: "${clip(record.what)}"`);
+        if (!chats.includes(record.id)) chats.push(record.id);
       } else if (record.taskId === task.id) {
         add("planned", `planned: ${DOMAIN_LABELS[record.domain ?? ""] ?? record.domain ?? "worker"} — ${clip(record.what)}`);
         if (record.domain && !domains.includes(record.domain)) domains.push(record.domain);
@@ -199,7 +201,7 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
     }
     if (before.has(path)) add("pre-existing", "pre-existing: it already had uncommitted changes before this task's agents started");
     if (kinds.length === 0) add("unattributed", "unattributed: no bot-lobby agent recorded editing it");
-    return { path, kinds, notes, quickFixes, ...(domains.length ? { domains } : {}) };
+    return { path, kinds, notes, chats, ...(domains.length ? { domains } : {}) };
   });
 }
 
@@ -208,7 +210,7 @@ export const MAX_PROVENANCE_LINES = 60;
 
 /** The provenance as the reviewer reads it: one line per changed file, the unexplained ones first, the rest counted past `max`. */
 export function provenanceLines(files: readonly FileProvenance[], max = MAX_PROVENANCE_LINES): string {
-  const order = (file: FileProvenance) => (file.kinds.includes("unattributed") ? 0 : file.kinds.includes("quickfix") ? 1 : 2);
+  const order = (file: FileProvenance) => (file.kinds.includes("unattributed") ? 0 : file.kinds.includes("chat") ? 1 : 2);
   const sorted = [...files].sort((a, b) => order(a) - order(b));
   const lines = sorted.slice(0, max).map((file) => `- ${file.path} — ${file.notes.join("; ")}`);
   const rest = sorted.slice(max);
@@ -216,16 +218,16 @@ export function provenanceLines(files: readonly FileProvenance[], max = MAX_PROV
   return lines.join("\n");
 }
 
-/** A one-line count for the Master: `4 planned · 1 quick fix (QF-2) · 1 unattributed (src/x.ts)`. */
+/** A one-line count for the Master: `4 planned · 1 by lobby chat (CHAT-2) · 1 unattributed (src/x.ts)`. */
 export function provenanceSummary(files: readonly FileProvenance[]): string {
   const count = (kind: Provenance) => files.filter((file) => file.kinds.includes(kind));
   const parts: string[] = [];
   const planned = count("planned").length;
   if (planned > 0) parts.push(`${planned} planned`);
-  const quick = count("quickfix");
-  if (quick.length > 0) {
-    const ids = [...new Set(quick.flatMap((file) => file.quickFixes))];
-    parts.push(`${quick.length} by quick fix (${ids.join(", ")})`);
+  const chat = count("chat");
+  if (chat.length > 0) {
+    const ids = [...new Set(chat.flatMap((file) => file.chats))];
+    parts.push(`${chat.length} by lobby chat (${ids.join(", ")})`);
   }
   const other = count("other-task").length;
   if (other > 0) parts.push(`${other} by another task`);

package/src/state/metrics.ts

@@ -1,6 +1,6 @@
 /**
  * Model performance records: one line per finished run of any agent — the
- * Master's own turns, scouts, workers, the QA gate, researchers, quick fixes,
+ * Master's own turns, scouts, workers, the QA gate, researchers, lobby chat agents,
  * planner turns and planning panel seats — so the lobby can show how long each model takes at each
  * thinking level, how often it succeeds and what it costs. Append-only JSON
  * lines per project; reads keep the newest `MAX_READ` records.
@@ -11,7 +11,8 @@ import type { AgentRun } from "../schemas/findings.ts";
 import type { RunLogEntry, Task } from "../schemas/task.ts";
 import { dataRoot } from "./project.ts";
 
-export const METRIC_KINDS = ["master", "scout", "worker", "reviewer", "researcher", "quickfix", "planner", "panel", "classifier"] as const;
+/** `chat`: an agent answering in the lobby chat; `quickfix` is kept so older logs still read. */
+export const METRIC_KINDS = ["master", "scout", "worker", "reviewer", "researcher", "chat", "quickfix", "planner", "panel", "classifier"] as const;
 export type MetricKind = (typeof METRIC_KINDS)[number];
 
 export type MetricStatus = "success" | "failed" | "cancelled" | "timeout";
@@ -19,7 +20,7 @@ export type MetricStatus = "success" | "failed" | "cancelled" | "timeout";
 export interface MetricRecord {
   id: string;
   kind: MetricKind;
-  /** Display name of the agent: MASTER, DEV, DESIGN, QA, RESEARCH, QUICK FIX, ORACLE (planning). */
+  /** Display name of the agent: MASTER, DEV, DESIGN, QA, RESEARCH, SCOUT, ORACLE (planning). */
   agent: string;
   model?: string;
   thinking?: string;
@@ -37,7 +38,7 @@ export interface MetricRecord {
   purpose?: string;
   /** A run the classifier routed down: the configured profile it came from. */
   routedFrom?: string;
-  /** Classifier calls: what the decision spared (seat runs skipped, questions answered, quick fixes held). */
+  /** Classifier calls: what the decision spared (seat runs skipped, questions answered). */
   saved?: number;
 }
 
@@ -53,7 +54,6 @@ export interface ClassifierSummary {
   byPurpose: Record<string, number>;
   seatRunsSkipped: number;
   questionsAnswered: number;
-  quickFixesHeld: number;
   /** Agent runs the classifier routed down, and how many of them succeeded. */
   routed: number;
   routedOk: number;
@@ -72,14 +72,12 @@ export function summarizeClassifier(calls: readonly MetricRecord[], runs: readon
   const byPurpose: Record<string, number> = {};
   let seatRunsSkipped = 0;
   let questionsAnswered = 0;
-  let quickFixesHeld = 0;
   for (const record of calls) {
     const purpose = record.purpose ?? "other";
     byPurpose[purpose] = (byPurpose[purpose] ?? 0) + 1;
     const saved = record.saved ?? 0;
     if (purpose === "seats") seatRunsSkipped += saved;
     else if (purpose === "answers") questionsAnswered += saved;
-    else if (purpose === "triage") quickFixesHeld += saved;
   }
   return {
     calls: calls.length,
@@ -90,7 +88,6 @@ export function summarizeClassifier(calls: readonly MetricRecord[], runs: readon
     byPurpose,
     seatRunsSkipped,
     questionsAnswered,
-    quickFixesHeld,
     routed: routed.length,
     routedOk: routed.filter((record) => record.status === "success").length,
   };

package/src/state/recovery.ts

@@ -6,8 +6,8 @@
  * background sessions it drives, and whether each was in the middle of a turn.
  * A window that quits on purpose removes it; one that stops any other way
  * leaves it behind, and the next window to start in the project takes it over
- * (`claimStoppedWindows`). Each session's planning panel and quick-fix queue
- * are kept beside it, by session, so they carry on as well.
+ * (`claimStoppedWindows`). Each session's planning panel is
+ * kept beside it, by session, so it carries on as well.
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -39,7 +39,7 @@ export interface WindowRecord {
 }
 
 /** What each kept session state holds. */
-export type SessionStateKind = "planner" | "quickfix";
+export type SessionStateKind = "planner";
 
 /** This process's token: written into its record, so a later process with the same pid is not mistaken for it. */
 const TOKEN = randomBytes(8).toString("hex");

package/src/webui/api/index.ts

@@ -14,7 +14,6 @@ import { statusGet } from "./status.ts";
 import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
 import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave, plannerPrevious, plannerPreviousArchive, plannerPreviousDelete, plannerPreviousGet, plannerPreviousOpen } from "./planner.ts";
-import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
 import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver, tasksAccept, tasksSkipStep, tasksForceClose, tasksResolveApproval } from "./tasks.ts";
 import { knowledgeAdd, knowledgeAsk, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { plansDiscard, plansGet, plansStart } from "./plans.ts";
@@ -26,6 +25,7 @@ import { terminalClose, terminalInput, terminalList, terminalOpen, terminalResiz
 import { MAX_INPUT_CHARS } from "../terminal.ts";
 import { themesChoose, themesGet, themesRemove, themesRename, themesSave } from "./themes.ts";
 import { noticeText, pushNotice } from "../notices.ts";
+import { codeChanges, codeRead, codeSave } from "../code.ts";
 
 /** What a handler reads besides the request body. */
 export interface ApiContext {
@@ -296,23 +296,6 @@ function buildRoutes(): Record<string, Route> {
   routes["planner.previousArchive"] = { schema: Type.Object({ id: PlanId, archived: Type.Boolean() }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousArchive(body as { id: string; archived: boolean }, ctx) };
   routes["planner.previousDelete"] = { schema: Type.Object({ id: PlanId }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousDelete(body as { id: string }, ctx) };
   routes["planner.previousOpen"] = { schema: Type.Object({ id: PlanId }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousOpen(body as { id: string }, ctx) };
-  routes["quickfix.list"] = { schema: Empty, run: (_body, ctx) => quickfixList(ctx) };
-  routes["quickfix.submit"] = {
-    schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
-    run: (body, ctx) => quickfixSubmit(body as { text: string; attachments?: string[] }, ctx),
-  };
-  routes["quickfix.cancel"] = {
-    schema: Type.Object({ id: TaskId }, { additionalProperties: false }),
-    run: (body, ctx) => quickfixCancel(body as { id: string }, ctx),
-  };
-  routes["quickfix.runAnyway"] = {
-    schema: Type.Object({ id: TaskId }, { additionalProperties: false }),
-    run: (body, ctx) => quickfixRunAnyway(body as { id: string }, ctx),
-  };
-  routes["quickfix.movedToTask"] = {
-    schema: Type.Object({ id: TaskId }, { additionalProperties: false }),
-    run: (body, ctx) => quickfixMovedToTask(body as { id: string }, ctx),
-  };
   routes["knowledge.files"] = { schema: Empty, run: (_body, ctx) => knowledgeFiles(ctx) };
   routes["knowledge.ask"] = {
     schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
@@ -378,6 +361,17 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ text: Type.String({ maxLength: 20_000 }) }, { additionalProperties: false }),
     run: (body, ctx) => issuesCreate(body as { text: string }, ctx),
   };
+  const codeRoot = (ctx: ApiContext) => ctx.service.projectRoot?.() ?? process.cwd();
+  const CodePath = Type.String({ minLength: 1, maxLength: 4096 });
+  routes["code.changes"] = { schema: Empty, run: (_body, ctx) => codeChanges(codeRoot(ctx)) };
+  routes["code.read"] = {
+    schema: Type.Object({ path: CodePath }, { additionalProperties: false }),
+    run: (body, ctx) => codeRead(codeRoot(ctx), (body as { path: string }).path),
+  };
+  routes["code.save"] = {
+    schema: Type.Object({ path: CodePath, contents: Type.String({ maxLength: 900_000 }), mtimeMs: Type.Optional(Type.Number()), force: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
+    run: (body, ctx) => codeSave(codeRoot(ctx), body as { path: string; contents: string; mtimeMs?: number; force?: boolean }),
+  };
   routes["settings.get"] = { schema: Empty, run: (_body, ctx) => settingsGet(ctx) };
   routes["settings.set"] = {
     // The patch's shape is the normaliser's job (`resolveConfig`); only a plain object is required here.

package/src/webui/api/lobby.ts

@@ -1,8 +1,9 @@
 /**
  * The Lobby tab over HTTP: one snapshot (task header, runs, newest chat,
  * streaming reply, activity, thoughts, older-chat flag), older chat history,
- * sending text to the oracle, and stopping its turn. Bounds come from the
- * feed module, so the page sees exactly what the terminal keeps.
+ * sending to the chat (the oracle, an agent, /plan or /task), and stopping
+ * whoever is answering. Bounds come from the feed module, so the page sees
+ * exactly what the terminal keeps.
  */
 import { MAX_ACTIVITY, MAX_CHAT, MAX_THOUGHTS } from "../../lobby/feed.ts";
 import type { Task } from "../../schemas/task.ts";
@@ -52,7 +53,8 @@ export function lobbySnapshot(ctx: ApiContext): LobbySnapshot {
   return {
     ...(taskOf(ctx) ? { task: taskOf(ctx)! } : {}),
     runs: [...service.zen().runs],
-    chat: feed.chat.slice(-MAX_CHAT).map((entry) => ({ id: entry.id, at: entry.at, role: entry.role, text: entry.text })),
+    chat: feed.chat.slice(-MAX_CHAT).map((entry) => ({ id: entry.id, at: entry.at, role: entry.role, text: entry.text, ...(entry.agent ? { agent: entry.agent } : {}), ...(entry.to ? { to: entry.to } : {}) })),
+    ...(service.answering?.() ? { answering: service.answering!()! } : {}),
     ...(reply ? { reply } : {}),
     activity: feed.activity.slice(-MAX_ACTIVITY).map((entry) => ({
       id: entry.id,
@@ -82,10 +84,11 @@ export function lobbyHistory(body: { before?: number }, ctx: ApiContext): { entr
 }
 
 /** Text for the oracle; a notice when it was not simply sent. */
-export function lobbySend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
+export function lobbySend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string; open?: "plan" } {
   if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
-  const notice = ctx.service.toOracle(withAttachments(body.text, body.attachments, ctx.service.zen().task?.id, ctx.service.projectRoot?.()));
-  return notice ? { notice } : {};
+  const sent = ctx.service.toOracle(withAttachments(body.text, body.attachments, ctx.service.zen().task?.id, ctx.service.projectRoot?.()));
+  if (!sent) return {};
+  return typeof sent === "string" ? { notice: sent } : sent;
 }
 
 /** Stop the oracle's turn. */