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

package/src/lobby/feed.ts

@@ -14,7 +14,7 @@ export type ActivityKind = "info" | "success" | "warning" | "error";
 export interface ActivityEntry {
   id: number;
   at: number;
-  /** Who acted: MASTER, DEV, DESIGN, QA, RESEARCH, QUICK FIX, PLANNER, LOBBY. */
+  /** Who acted: MASTER, DEV, DESIGN, QA, RESEARCH, SCOUT, PLANNER, LOBBY. */
   source: string;
   text: string;
   kind: ActivityKind;
@@ -35,13 +35,24 @@ export interface ThoughtEntry {
 
 export type ChatRole = "you" | "oracle" | "note";
 
-export interface ChatEntry {
+/** Who a message was for (yours) or who wrote it (a reply): `DESIGN`, `DEV`, …; absent is the oracle. */
+export interface ChatSpeaker {
+  /** The agent that wrote a reply. */
+  agent?: string;
+  /** The agent your message went to. */
+  to?: string;
+}
+
+export interface ChatEntry extends ChatSpeaker {
   id: number;
   at: number;
   role: ChatRole;
   text: string;
 }
 
+/** A conversation line before it is numbered: what the session's entries read as. */
+export type ChatLine = { role: ChatRole; text: string; at?: number } & ChatSpeaker;
+
 export const MAX_ACTIVITY = 400;
 export const MAX_THOUGHTS = 40;
 /** Messages the conversation keeps in memory; earlier ones are loaded from the session when scrolled to. */
@@ -71,7 +82,7 @@ export class LobbyFeed {
   /** Last step reported per run, so repeated run updates log each step once. */
   private readonly runSteps = new Map<string, string>();
   private readonly runThoughts = new Map<string, string>();
-  /** The live whole thought of each piece of work still under way (a run, a quick fix, a review), by its key. */
+  /** The live whole thought of each piece of work still under way (a run, a chat agent's reply, a review), by its key. */
   private readonly liveThoughts = new Map<string, number>();
   private readonly runStatus = new Map<string, AgentRun["status"]>();
   /** Runs already reported as switched to their fallback model. */
@@ -122,6 +133,11 @@ export class LobbyFeed {
     if (this.settle(undefined, key, isError ? "error" : undefined)) this.touch();
   }
 
+  /** Settle every step `source` still has open (a turn that ended without closing its tool calls). */
+  endAll(source: string): void {
+    if (this.settle(source, undefined)) this.touch();
+  }
+
   /** The next step of an agent that reports one step at a time: the previous one settles. */
   step(source: string, text: string, key: string, at = Date.now()): void {
     this.settle(undefined, key);
@@ -165,7 +181,7 @@ export class LobbyFeed {
   }
 
   /**
-   * A whole thought from work still under way (`key`: its run, quick fix or
+   * A whole thought from work still under way (`key`: its run, chat reply or
    * review): live, so the Thinking orb takes its agent's colour, until the
    * same work's next thought or `settleThought(key)` when it ends.
    */
@@ -214,6 +230,15 @@ export class LobbyFeed {
     this.say("you", body, at);
   }
 
+  /** Mark the newest message of yours with this text as one that went to `to` (an agent, not the oracle). */
+  addressed(text: string, to: string): void {
+    const body = text.trim();
+    const entry = [...this.chat].reverse().find((line) => line.role === "you" && line.text === body);
+    if (!entry || entry.to === to) return;
+    entry.to = to;
+    this.touch();
+  }
+
   /** Whether `text` is a queued message already on show; it is forgotten once delivered. */
   takeQueued(text: string): boolean {
     const index = this.queued.indexOf(text.trim());
@@ -222,10 +247,10 @@ export class LobbyFeed {
     return true;
   }
 
-  say(role: ChatRole, text: string, at = Date.now()): void {
+  say(role: ChatRole, text: string, at = Date.now(), speaker: ChatSpeaker = {}): void {
     const body = text.trim();
     if (!body) return;
-    this.chat.push({ id: this.nextId++, at, role, text: body });
+    this.chat.push({ id: this.nextId++, at, role, text: body, ...speaker });
     if (this.chat.length > MAX_CHAT) {
       this.chat.splice(0, this.chat.length - MAX_CHAT);
       this.chatOlder = true;
@@ -234,10 +259,10 @@ export class LobbyFeed {
   }
 
   /** Replace the conversation (seeding from the session when the lobby first opens); only the newest `MAX_CHAT` are kept. */
-  seedChat(entries: ReadonlyArray<{ role: ChatRole; text: string; at?: number }>): void {
+  seedChat(entries: readonly ChatLine[]): void {
     const kept = entries.filter((entry) => entry.text.trim());
     this.chatOlder = kept.length > MAX_CHAT;
-    this.chat = kept.slice(-MAX_CHAT).map((entry) => ({ id: this.nextId++, at: entry.at ?? 0, role: entry.role, text: entry.text.trim() }));
+    this.chat = kept.slice(-MAX_CHAT).map((entry) => ({ id: this.nextId++, at: entry.at ?? 0, role: entry.role, text: entry.text.trim(), ...(entry.agent ? { agent: entry.agent } : {}), ...(entry.to ? { to: entry.to } : {}) }));
     this.touch();
   }
 
@@ -343,18 +368,18 @@ export function chatText(role: "user" | "assistant", text: string): Array<{ role
   const kickoff = /^A bot-lobby task is active: (\S+)\nTitle: (.*)/.exec(body);
   if (kickoff) {
     const request = /\nRequest: ([\s\S]*?)(?:\nState: |$)/.exec(body)?.[1]?.trim();
-    // A request the oracle routed to the team is already in the conversation, under the routing note.
-    const shown = /\nRouted: /.test(body);
-    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request && !shown ? [{ role: "you" as const, text: request }] : [])];
+    return [{ role: "note", text: `task started · ${kickoff[2]}` }, ...(request ? [{ role: "you" as const, text: request }] : [])];
   }
-  // A new request the classifier read as a quick fix, before the oracle confirms where it goes.
-  const routing = /^bot-lobby: a new request, not a task yet\.\nRequest: ([\s\S]*?)\nRead: /.exec(body);
-  if (routing) return [{ role: "you", text: routing[1]!.trim() }, { role: "note", text: "reads as a quick fix · the oracle confirms where it goes" }];
+  // Auto mode's nudge to keep going (pi/owner.ts autoNudge) shows as one short line.
+  if (/^Auto mode: \S+ is \S+\. Keep driving it to completion/.test(body)) return [{ role: "note", text: AUTO_NOTE }];
   const comment = /^The user left (?:a comment|\d+ comments) on (the approved plan|the proposal) of (\S+) from the lobby:/.exec(body);
   if (comment) return [{ role: "note", text: `your comment on ${comment[1]} went to the oracle` }];
   return [{ role: "you", text: body }];
 }
 
+/** What the conversation shows where auto mode kept the oracle going. */
+export const AUTO_NOTE = "auto mode";
+
 /** The session entry bot-lobby leaves where the oracle's context starts over (see pi/fresh-context.ts). */
 export const CONTEXT_MARK = "bot-lobby-context";
 
@@ -367,9 +392,34 @@ export function isClearedMark(entry: unknown): boolean {
   return record?.type === "custom" && record.customType === CONTEXT_MARK && record.data?.kind === "end";
 }
 
-/** Session entries (`{ type: "message", message }`) as conversation entries, oldest first. */
-export function chatFromEntries(entries: readonly unknown[], max = MAX_CHAT): Array<{ role: ChatRole; text: string; at?: number }> {
-  const chat: Array<{ role: ChatRole; text: string; at?: number }> = [];
+/** The session entry that keeps one line of the lobby chat an agent other than the oracle took part in. */
+export const CHAT_MARK = "bot-lobby-chat";
+
+/** What a `CHAT_MARK` entry carries: your message to an agent, or its reply. */
+export interface ChatMarkDetails {
+  role: "you" | "agent";
+  /** The agent: who it went to, or who replied. */
+  agent: string;
+  text: string;
+}
+
+/** What the Master reads of a lobby line it did not take part in (the entry's content). */
+export function chatMarkContent(details: ChatMarkDetails): string {
+  return details.role === "you" ? `The user asked ${details.agent} in the lobby chat:\n\n${details.text}` : `${details.agent} answered in the lobby chat:\n\n${details.text}`;
+}
+
+/** A `CHAT_MARK` session entry as its conversation line; undefined for any other entry. */
+export function chatMarkLine(entry: unknown): ChatLine | undefined {
+  const record = entry as { type?: string; customType?: string; details?: Partial<ChatMarkDetails> } | undefined;
+  if (record?.type !== "custom_message" || record.customType !== CHAT_MARK) return undefined;
+  const details = record.details;
+  if (!details || typeof details.text !== "string" || typeof details.agent !== "string") return undefined;
+  return details.role === "you" ? { role: "you", text: details.text, to: details.agent } : { role: "oracle", text: details.text, agent: details.agent };
+}
+
+/** Session entries (`{ type: "message", message }`, and the chat's own marks) as conversation entries, oldest first. */
+export function chatFromEntries(entries: readonly unknown[], max = MAX_CHAT): ChatLine[] {
+  const chat: ChatLine[] = [];
   for (const entry of entries) {
     const record = entry as { type?: string; timestamp?: string; message?: { role?: string; content?: unknown } };
     if (isClearedMark(entry)) {
@@ -377,6 +427,12 @@ export function chatFromEntries(entries: readonly unknown[], max = MAX_CHAT): Ar
       chat.push({ role: "note", text: CLEARED_NOTE, ...(Number.isFinite(at) ? { at } : {}) });
       continue;
     }
+    const marked = chatMarkLine(entry);
+    if (marked) {
+      const at = record.timestamp ? Date.parse(record.timestamp) : Number.NaN;
+      chat.push({ ...marked, ...(Number.isFinite(at) ? { at } : {}) });
+      continue;
+    }
     if (record?.type !== "message") continue;
     const role = record.message?.role;
     if (role !== "user" && role !== "assistant") continue;

package/src/lobby/host.ts

@@ -11,7 +11,6 @@ import type { MetricRecord } from "../state/metrics.ts";
 import type { BotLobbyConfig, LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
 import type { ChatEntry, LobbyFeed } from "./feed.ts";
 import type { BackgroundSession } from "./sessions.ts";
-import type { QuickFixQueue } from "./quickfix.ts";
 import type { PlannerSeed, PlanningSession } from "./planner.ts";
 import type { PlanRecord, PlanSummary } from "../state/plan-history.ts";
 import type { IssuesState } from "./issues.ts";
@@ -88,6 +87,8 @@ export interface LobbyService {
   zen(): { task?: Task; runs: readonly AgentRun[] };
   feed: LobbyFeed;
   masterBusy(): boolean;
+  /** The agent other than the oracle answering in the chat now (`DESIGN`, …), if any. */
+  answering?(): string | undefined;
   tasks(): Task[];
   /** How long a task's agents have worked on it, and the worker runs under way (`work.json`); undefined without one. */
   work?(taskId: string): import("../state/work-time.ts").WorkProjection | undefined;
@@ -99,8 +100,12 @@ export interface LobbyService {
   metrics(): MetricRecord[];
   /** Classifier calls (kind `classifier`), kept out of the agent tables. */
   classifierMetrics?(): MetricRecord[];
-  /** Send text to the oracle, or start a task when none is active; returns a notice. */
-  toOracle(text: string): string | undefined;
+  /**
+   * A message in the lobby chat: to the oracle, the agent it names or the
+   * classifier picks, or a `/plan` or `/task`; returns a notice, and the tab
+   * to open when it moved somewhere else.
+   */
+  toOracle(text: string): string | { notice: string; open: "plan" } | undefined;
   /** Answer a project question and learn from the codebase, without creating a task. */
   askKnowledge(text: string): void;
   comment(taskId: string, text: string): string;
@@ -109,7 +114,6 @@ export interface LobbyService {
   startPlanned(plan: PlannedTask): string;
   discardPlan(id: string): void;
   abortMaster(): void;
-  quickfix: QuickFixQueue;
   planner(): PlanningSession | undefined;
   /** The project's previous plans (never saved as a task), newest first; the archived ones when asked. */
   previousPlans(archived: boolean): PlanSummary[];

package/src/lobby/keys.ts

@@ -13,6 +13,7 @@ export const LOBBY_ACTIONS = {
   activity: { key: "alt+a", help: "open or fold every step in the Lobby conversation" },
   thinking: { key: "alt+t", help: "show or hide Thinking on the Lobby" },
   terminal: { key: "ctrl+`", help: "show or hide the terminal" },
+  code: { key: "alt+e", help: "open or close the code viewer: changed files, diffs and editing" },
   nextTab: { key: "alt+]", help: "next tab" },
   prevTab: { key: "alt+[", help: "previous tab" },
 } as const;

package/src/lobby/planner.ts

@@ -31,7 +31,7 @@ import type { AskQuestion, AskResult } from "../ask/types.ts";
 import { PANEL_MEMBERS, type PanelMember } from "../schemas/configuration.ts";
 import { truncate } from "../text.ts";
 import type { LobbyFeed } from "./feed.ts";
-import type { QuickFixProfile } from "./quickfix.ts";
+import type { LobbyRunProfile } from "./profile.ts";
 import { MAX_QUESTIONS } from "./ask.ts";
 import type { Classifier } from "../classifier/classifier.ts";
 import { chooseSeats } from "../classifier/seats.ts";
@@ -138,9 +138,9 @@ export interface PlannerDeps {
   root: string;
   configDir: string;
   /** The oracle chairing the panel (the Planner settings entry). */
-  profile: () => QuickFixProfile;
+  profile: () => LobbyRunProfile;
   /** A seat's model, thinking and grants; the oracle's profile when absent. */
-  memberProfile?: (member: PanelMember) => QuickFixProfile;
+  memberProfile?: (member: PanelMember) => LobbyRunProfile;
   /** Seats on the panel when the session starts; every seat when absent. */
   panel?: readonly PanelMember[];
   stallTimeoutMs?: number;
@@ -995,7 +995,7 @@ export class PlanningSession {
     this.deps.onChange?.();
   }
 
-  private async run(label: string, kind: "planner" | "panel", profile: QuickFixProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
+  private async run(label: string, kind: "planner" | "panel", profile: LobbyRunProfile, request: { task: string; systemPrompt: string; tools: readonly string[] }, signal: AbortSignal, setStep: (step: string) => void, routedFrom?: string): Promise<RunOutcome> {
     const startedAt = Date.now();
     const runId = randomUUID();
     let outcome: RunOutcome;
@@ -1271,7 +1271,7 @@ export function planningMetric(
   turn: number,
   startedAt: number,
   status: MetricRecord["status"],
-  profile: QuickFixProfile,
+  profile: LobbyRunProfile,
   model: string | undefined,
   usage: { input: number; output: number; cost: number; turns: number },
   now = Date.now(),

package/src/lobby/pr-review.ts

@@ -19,7 +19,7 @@ import { dataRoot } from "../state/project.ts";
 import type { Classifier } from "../classifier/classifier.ts";
 import { readLine, readPull, type PullRead } from "../classifier/review.ts";
 import type { LobbyFeed } from "./feed.ts";
-import type { QuickFixProfile } from "./quickfix.ts";
+import type { LobbyRunProfile } from "./profile.ts";
 import { pullDiff, viewPull, type PullDetail } from "./pulls.ts";
 import type { Exec } from "./issues.ts";
 
@@ -75,7 +75,7 @@ export interface PullReviewDeps {
   configDir: string;
   exec: Exec;
   /** QA's model, thinking and grants, read as a review starts. */
-  profile: () => QuickFixProfile;
+  profile: () => LobbyRunProfile;
   stallTimeoutMs?: number;
   toolStallTimeoutMs?: number;
   feed?: LobbyFeed;

package/src/lobby/profile.ts

@@ -0,0 +1,16 @@
+import type { HarnessRun } from "../schemas/harness.ts";
+
+/** The model, thinking and grants a lobby agent (the planner, a panel seat, a pull request review) runs with, read from settings at start time. */
+export interface LobbyRunProfile {
+  model?: string;
+  thinking: string;
+  instructions?: string;
+  mcpTools?: string[];
+  /** Skill names it may load; absent keeps every skill pi finds. */
+  skills?: string[];
+  /** False when its settings turn the agent's auto-compaction off. */
+  autoCompact?: boolean;
+  /** The third-party harness it runs on; absent runs it on pi. */
+  harness?: HarnessRun;
+  compactAt?: number;
+}

package/src/lobby/prompts.ts

@@ -1,17 +1,17 @@
 /**
- * Strings the server and the page share: tab metadata and the short line
- * shown when a question was answered elsewhere. Pure on purpose (no
+ * Strings the server and the page share: tab metadata, the short line shown
+ * when a question was answered elsewhere, and the lobby chat's agents, @
+ * mentions and slash commands. Pure on purpose (no
  * `node:*`): the web page imports this file directly.
  */
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge"] as const;
+export const TAB_IDS = ["lobby", "tasks", "plan", "git", "knowledge"] as const;
 export type TabId = (typeof TAB_IDS)[number];
 
 export const TAB_LABELS: Record<TabId, string> = {
   lobby: "Lobby",
   tasks: "Tasks",
   plan: "Plan",
-  quickfix: "Quick fix",
   git: "Git",
   knowledge: "Knowledge",
 };
@@ -26,3 +26,55 @@ export const ANSWERED_ELSEWHERE = "already answered in another window";
 
 /** Opens the list of files a message carries (see src/webui/uploads.ts); the page shows them as thumbnails and chips. */
 export const ATTACHMENTS_MARK = "Attached files:";
+
+/* ------------------------------------------------------------ the lobby chat */
+
+/** Who can answer in the lobby chat: the oracle (MASTER) or one of the agents, on its own settings. */
+export const CHAT_AGENTS = ["master", "designer", "backend", "qa", "researcher", "scout"] as const;
+export type ChatAgent = (typeof CHAT_AGENTS)[number];
+
+/** Each one's name as the feeds and the chat show it. */
+export const CHAT_AGENT_SOURCES: Record<ChatAgent, string> = {
+  master: "MASTER",
+  designer: "DESIGN",
+  backend: "DEV",
+  qa: "QA",
+  researcher: "RESEARCH",
+  scout: "SCOUT",
+};
+
+/** The @ names the composer offers, in its menu's order, with what each one is for. */
+export const CHAT_MENTIONS: ReadonlyArray<{ name: string; agent: ChatAgent; hint: string }> = [
+  { name: "master", agent: "master", hint: "The oracle: anything, and changes across the project" },
+  { name: "design", agent: "designer", hint: "Frontend: pages, components, styling and UX" },
+  { name: "dev", agent: "backend", hint: "Backend: APIs, data and server code" },
+  { name: "qa", agent: "qa", hint: "Tests, and how to check a change" },
+  { name: "research", agent: "researcher", hint: "Facts from the web: libraries, versions, docs" },
+  { name: "scout", agent: "scout", hint: "Reads the code and explains how something works" },
+];
+
+/** Other spellings an @ mention may use. */
+const MENTION_ALIASES: Record<string, ChatAgent> = { oracle: "master", designer: "designer", frontend: "designer", backend: "backend", researcher: "researcher" };
+
+/** A message that opens with `@name`: who it is for and the rest of it; undefined for any other message. */
+export function parseMention(text: string): { agent: ChatAgent; rest: string } | undefined {
+  const match = /^\s*@([a-z]+)(?=\s|$)\s*/i.exec(text);
+  if (!match) return undefined;
+  const name = match[1]!.toLowerCase();
+  const agent = CHAT_MENTIONS.find((entry) => entry.name === name)?.agent ?? MENTION_ALIASES[name];
+  return agent ? { agent, rest: text.slice(match[0].length) } : undefined;
+}
+
+/** The lobby's slash commands: the chat does the work until you ask for a plan or a task. */
+export const LOBBY_COMMANDS = [
+  { name: "plan", args: "what to plan", hint: "Plan it with the panel on the Plan tab" },
+  { name: "task", args: "what to do", hint: "Start it as a task for the team" },
+] as const;
+export type LobbyCommand = (typeof LOBBY_COMMANDS)[number]["name"];
+
+/** A message that opens with one of the lobby's commands: which, and the rest of it; undefined for anything else. */
+export function parseLobbyCommand(text: string): { command: LobbyCommand; rest: string } | undefined {
+  const match = /^\s*\/([a-z]+)(?=\s|$)\s*/i.exec(text);
+  const command = LOBBY_COMMANDS.find((entry) => entry.name === match?.[1]?.toLowerCase())?.name;
+  return match && command ? { command, rest: text.slice(match[0].length) } : undefined;
+}

package/src/lobby/recovery.ts

@@ -1,14 +1,13 @@
 /**
  * Carrying on after pi stops unexpectedly. A window running the lobby keeps
- * what it is doing on disk as it changes: its planning panel and quick-fix
- * queue (by session), and a record of the sessions it drives and whether each
+ * what it is doing on disk as it changes: its planning panel (by session),
+ * and a record of the sessions it drives and whether each
  * was mid-turn (src/state/recovery.ts). Quitting on purpose removes the
  * record; a crash, a kill or a closed terminal leaves it.
  *
  * The next window to start the lobby in the project takes the stopped
  * windows over: the planning panel comes back where it was (a round that was
- * cut off runs again), queued quick fixes run (the one cut off runs again),
- * and every session that drove a task still under way is started again from
+ * cut off runs again), and every session that drove a task still under way is started again from
  * its saved file, its oracle told to pick up where it stopped when it was
  * mid-turn. A window that is that same session again (`pi -c`) carries its
  * own task on itself. Nothing here runs in a subagent or a background session.
@@ -32,7 +31,6 @@ import {
 } from "../state/recovery.ts";
 import { isPlanningSnapshot, type PlanningSession, type PlanningSnapshot } from "./planner.ts";
 import { keepPlan } from "../state/plan-history.ts";
-import type { QuickFixJob } from "./quickfix.ts";
 import type { BackgroundSession } from "./sessions.ts";
 
 /** Writes after a change wait this long, so a burst of changes is one write. */
@@ -87,7 +85,6 @@ export interface RecoveryPlan {
   windows: WindowRecord[];
   /** Kept state to hand to this session, from the newest stopped window that has it. */
   planner?: { from: string };
-  quickfix: string[];
   relaunch: Relaunch[];
   /** This window is the stopped one's session again, and its task is under way. */
   own?: { taskId: string; message?: string };
@@ -107,7 +104,7 @@ export function planRecovery(input: {
   running: ReadonlySet<string>;
 }): RecoveryPlan {
   const { root, configDir, sessionId } = input;
-  const plan: RecoveryPlan = { windows: [...input.windows], quickfix: [], relaunch: [] };
+  const plan: RecoveryPlan = { windows: [...input.windows], relaunch: [] };
   const hasOwnPlanner = isPlanningSnapshot(readSessionState(root, configDir, "planner", sessionId));
   const seen = new Set<string>();
   const consider = (session: { sessionId: string; sessionFile?: string; name?: string; working: boolean }) => {
@@ -127,7 +124,6 @@ export function planRecovery(input: {
     if (!hasOwnPlanner && !plan.planner && window.sessionId !== sessionId && isPlanningSnapshot(readSessionState(root, configDir, "planner", window.sessionId))) {
       plan.planner = { from: window.sessionId };
     }
-    if (window.sessionId !== sessionId && Array.isArray(readSessionState(root, configDir, "quickfix", window.sessionId))) plan.quickfix.push(window.sessionId);
     consider({ sessionId: window.sessionId, ...(window.sessionFile ? { sessionFile: window.sessionFile } : {}), working: window.working });
     for (const background of window.background) consider(background);
   }
@@ -143,17 +139,14 @@ export interface RecoveryHost {
   relaunch(start: Relaunch): BackgroundSession | string;
   /** Restore the planning panel from a snapshot (and run again a round it cut off). */
   restorePlanner(snapshot: PlanningSnapshot): void;
-  /** Take up quick-fix jobs a stopped process left; returns how many will run. */
-  restoreQuickFixes(jobs: readonly QuickFixJob[]): number;
   /** Send this window's oracle the nudge, once it is idle. */
   nudge(message: string): void;
 }
 
 /** What carried on, in words, or undefined when nothing did. */
-export function recoverySummary(parts: { planner: boolean; quickfixes: number; tasks: string[] }): string | undefined {
+export function recoverySummary(parts: { planner: boolean; tasks: string[] }): string | undefined {
   const done = [
     parts.planner ? "the planning session" : "",
-    parts.quickfixes > 0 ? `${parts.quickfixes} quick fix${parts.quickfixes === 1 ? "" : "es"}` : "",
     parts.tasks.length > 0 ? `${parts.tasks.length === 1 ? "task" : "tasks"} ${parts.tasks.join(", ")}` : "",
   ].filter(Boolean);
   if (done.length === 0) return undefined;
@@ -163,7 +156,7 @@ export function recoverySummary(parts: { planner: boolean; quickfixes: number; t
 
 /**
  * Carry on what the stopped windows were doing, and this session's own kept
- * planning panel and quick-fix queue. Returns the summary to show, if any.
+ * planning panel. Returns the summary to show, if any.
  */
 export function recover(host: RecoveryHost): string | undefined {
   const { root, configDir, sessionId } = host;
@@ -182,14 +175,6 @@ export function recover(host: RecoveryHost): string | undefined {
   const planner = isPlanningSnapshot(snapshot);
   if (planner) host.restorePlanner(snapshot);
 
-  const jobs: QuickFixJob[] = [];
-  for (const from of [sessionId, ...plan.quickfix]) {
-    const kept = readSessionState(root, configDir, "quickfix", from);
-    if (Array.isArray(kept)) jobs.push(...(kept as QuickFixJob[]));
-    if (from !== sessionId) removeSessionState(root, configDir, "quickfix", from);
-  }
-  const quickfixes = jobs.length > 0 ? host.restoreQuickFixes(jobs) : 0;
-
   const tasks: string[] = [];
   for (const start of plan.relaunch) {
     settleInterrupted(root, configDir, start.taskId);
@@ -202,7 +187,7 @@ export function recover(host: RecoveryHost): string | undefined {
     tasks.push(plan.own.taskId);
   }
   // A restart after a quit restores the panel quietly; only carrying on after a stop is announced.
-  return windows.length > 0 ? recoverySummary({ planner, quickfixes, tasks }) : undefined;
+  return windows.length > 0 ? recoverySummary({ planner, tasks }) : undefined;
 }
 
 /** Whether a window in this project stopped without quitting: the lobby then starts on, to carry its work on. */
@@ -271,22 +256,20 @@ export interface KeeperSource {
   /** This window's oracle is mid-turn. */
   working: () => boolean;
   planner: () => PlanningSession | undefined;
-  quickfix: () => readonly QuickFixJob[];
   background: () => readonly BackgroundSession[];
 }
 
 /**
- * Keeps this window's record, planning panel and quick-fix queue on disk as
+ * Keeps this window's record and planning panel on disk as
  * they change, for the next window to carry on after a stop.
  */
 export class WindowKeeper {
   private readonly startedAt = new Date().toISOString();
   readonly window: Debounced;
   readonly planner: Debounced;
-  readonly quickfix: Debounced;
   /** pi going down on an uncaught error skips the shutdown: what is waiting is written as the process exits. */
   private readonly onExit = () => {
-    for (const writer of [this.planner, this.quickfix, this.window]) writer.close();
+    for (const writer of [this.planner, this.window]) writer.close();
   };
   private readonly source: KeeperSource;
   constructor(source: KeeperSource) {
@@ -297,11 +280,6 @@ export class WindowKeeper {
       const session = source.planner();
       if (session) this.keepPlanner(session, session.snapshot());
     });
-    this.quickfix = new Debounced(() => {
-      const jobs = source.quickfix();
-      if (jobs.length > 0) writeSessionState(source.root, source.configDir, "quickfix", source.sessionId(), jobs);
-      else removeSessionState(source.root, source.configDir, "quickfix", source.sessionId());
-    });
   }
 
   /** The panel as this window's (to carry on) and among the project's plans (to read again later). */
@@ -331,7 +309,6 @@ export class WindowKeeper {
     process.off("exit", this.onExit);
     if (carryOn) {
       this.planner.close();
-      this.quickfix.close();
       this.window.close();
       return;
     }
@@ -340,14 +317,11 @@ export class WindowKeeper {
     try {
       const session = this.source.planner();
       if (session) this.keepPlanner(session, stoppedSnapshot(session.snapshot()));
-      const jobs = this.source.quickfix().map(stoppedJob);
-      if (jobs.length > 0) writeSessionState(root, configDir, "quickfix", sessionId, jobs);
-      else removeSessionState(root, configDir, "quickfix", sessionId);
       removeWindow(root, configDir);
     } catch {
       // A read-only project keeps nothing.
     }
-    for (const writer of [this.planner, this.quickfix, this.window]) writer.cancel();
+    for (const writer of [this.planner, this.window]) writer.cancel();
   }
 }
 
@@ -357,12 +331,6 @@ export function stoppedSnapshot(snapshot: PlanningSnapshot): PlanningSnapshot {
   return { ...snapshot, running: false, members: snapshot.members.map((member) => member.status === "thinking" ? { ...member, status: "failed", error: "stopped" } : member), error: STOPPED_ROUND };
 }
 
-/** What a stop on purpose leaves of a quick fix that was queued or running: cancelled. */
-export function stoppedJob(job: QuickFixJob): QuickFixJob {
-  if (job.status !== "queued" && job.status !== "running") return job;
-  return { ...job, status: "cancelled", note: "stopped when the lobby stopped", ...(job.finishedAt ? {} : { finishedAt: Date.now() }) };
-}
-
 /** A round stopped by a quit, as the Plan tab shows it. */
 export const STOPPED_ROUND = "stopped when the lobby stopped — retry runs the round again";