@a-t-h-i/bot-lobby 0.6.24 → 0.6.26

package/src/lobby/planner.ts

@@ -61,8 +61,13 @@ const MEMBER_SEATS: Record<PanelMember, string> = {
 export interface PanelOption {
   label: string;
   description: string;
+  /** A static HTML/CSS mockup of the option (a fenced `mockup` block under it), shown as a thumbnail the user expands. */
+  mockup?: { html: string; css?: string };
 }
 
+/** Longest mockup kept per option; a longer one is dropped rather than cut mid-tag. */
+export const MAX_MOCKUP_CHARS = 30_000;
+
 /** A question as a seat or the oracle wrote it, with the options it offers (recommended first). */
 export interface AskedQuestion {
   text: string;
@@ -273,7 +278,22 @@ export function questionItems(body: string | undefined): AskedQuestion[] {
   if (!body) return [];
   const items: AskedQuestion[] = [];
   let current: AskedQuestion | undefined;
+  // A fenced `mockup` (or `html`) block under an option is that option's mockup, never more question text.
+  let fence: { option?: PanelOption | undefined; lines: string[]; marker: string } | undefined;
   for (const line of body.split("\n")) {
+    if (fence) {
+      if (line.trim() === fence.marker) {
+        const html = dedent(fence.lines).trim();
+        if (fence.option && html && html.length <= MAX_MOCKUP_CHARS) fence.option.mockup = { html };
+        fence = undefined;
+      } else fence.lines.push(line);
+      continue;
+    }
+    const opening = /^\s*(`{3,}|~{3,})\s*(?:mockup|html)\s*$/i.exec(line);
+    if (opening) {
+      fence = { lines: [], marker: opening[1]!, ...(current?.options.length ? { option: current.options.at(-1) } : {}) };
+      continue;
+    }
     const match = /^(\s*)(?:\d+[.)]|[-*])\s+(.*\S)\s*$/.exec(line);
     if (match && (match[1]!.length === 0 || !current)) {
       current = { text: match[2]!.replace(/\*\*/g, ""), options: [] };
@@ -289,6 +309,34 @@ export function questionItems(body: string | undefined): AskedQuestion[] {
   return items.map(inlineOptions);
 }
 
+/** Lines with their shared indentation removed. */
+function dedent(lines: readonly string[]): string {
+  const indents = lines.filter((line) => line.trim()).map((line) => /^\s*/.exec(line)![0].length);
+  const cut = indents.length ? Math.min(...indents) : 0;
+  return lines.map((line) => line.slice(cut)).join("\n");
+}
+
+const plainOption = (label: string): string => optionLabel({ label, description: "" }).toLowerCase();
+
+/**
+ * The oracle relays a seat's question in its own words, without repeating the
+ * seat's mockups: an option it keeps by label keeps the seat's mockup (from
+ * the seat it tags first, then any seat).
+ */
+export function carryMockups(questions: readonly PanelQuestion[], seatQuestions: readonly PanelQuestion[]): PanelQuestion[] {
+  const drawn = seatQuestions.flatMap((question) => question.options.filter((option) => option.mockup).map((option) => ({ from: question.from, label: plainOption(option.label), mockup: option.mockup! })));
+  if (drawn.length === 0) return [...questions];
+  return questions.map((question) => ({
+    ...question,
+    options: question.options.map((option) => {
+      if (option.mockup) return option;
+      const label = plainOption(option.label);
+      const match = drawn.find((entry) => entry.label === label && entry.from === question.from) ?? drawn.find((entry) => entry.label === label);
+      return match ? { ...option, mockup: match.mockup } : option;
+    }),
+  }));
+}
+
 /**
  * The round's questions for the user. The oracle chooses them from its own
  * and the seats' (tagged with the seat each serves) and decides the rest; only
@@ -296,7 +344,7 @@ export function questionItems(body: string | undefined): AskedQuestion[] {
  * `MAX_QUESTIONS`, so a round is answered in one questionnaire.
  */
 export function roundQuestions(reply: PlannerReply | undefined, seatQuestions: readonly PanelQuestion[]): PanelQuestion[] {
-  const chosen = reply ? reply.questions.map((question) => tagged(question, ORACLE_LABEL)) : [...seatQuestions];
+  const chosen = reply ? carryMockups(reply.questions.map((question) => tagged(question, ORACLE_LABEL)), seatQuestions) : [...seatQuestions];
   return chosen.slice(0, MAX_QUESTIONS);
 }
 
@@ -330,8 +378,8 @@ export function parseMemberReply(text: string): MemberReply {
   return { status: ready ? "ready" : "open", questions, notes: listItems(parts.get("notes")) };
 }
 
-function optionLines(options: readonly PanelOption[]): string[] {
-  return options.map((option) => `   - ${option.label}${option.description ? ` — ${option.description}` : ""}`);
+function optionLines(options: readonly PanelOption[], marks = false): string[] {
+  return options.map((option) => `   - ${option.label}${option.description ? ` — ${option.description}` : ""}${marks && option.mockup ? " [mockup]" : ""}`);
 }
 
 function questionLine(question: PanelQuestion, index: number): string {
@@ -429,7 +477,7 @@ export function panelSection(outcomes: readonly MemberOutcome[]): string {
     const { status, questions, notes } = outcome.reply;
     return [
       `### ${label} — ${status === "ready" ? "READY" : "OPEN"}`,
-      questions.length > 0 ? `Questions for the user:\n${questions.map((question) => [`- ${question.text}`, ...optionLines(question.options)].join("\n")).join("\n")}` : "",
+      questions.length > 0 ? `Questions for the user:\n${questions.map((question) => [`- ${question.text}`, ...optionLines(question.options, true)].join("\n")).join("\n")}` : "",
       notes.length > 0 ? `Notes:\n${notes.map((note) => `- ${note}`).join("\n")}` : "",
     ].filter(Boolean).join("\n");
   });
@@ -798,7 +846,7 @@ export class PlanningSession {
       const step = describeToolCall(event.toolName, event.args);
       setStep(step);
       this.deps.feed?.step(label, step, this.stepKey(label));
-    } else if (event.type === "thought") this.deps.feed?.thought(label, event.text);
+    } else if (event.type === "thought") this.deps.feed?.liveThought(label, event.text, this.stepKey(label));
     else if (event.type === "thinking" || event.type === "writing") setStep(event.type);
     else return;
     this.deps.onChange?.();
@@ -828,6 +876,7 @@ export class PlanningSession {
       outcome = { status: "failed", output: "", error: (error as Error).message, usage: { input: 0, output: 0, cost: 0, turns: 0 } };
     }
     this.deps.feed?.end(this.stepKey(label), outcome.status !== "success");
+    this.deps.feed?.settleThought(this.stepKey(label));
     const metric = planningMetric(kind, label, this.turns, startedAt, outcome.status, profile, outcome.model, outcome.usage);
     appendMetrics(this.deps.root, this.deps.configDir, [routedFrom ? { ...metric, routedFrom } : metric]);
     return outcome;

package/src/lobby/pr-review.ts

@@ -258,7 +258,7 @@ export class PullReviews {
 
   private onEvent(review: PullReview, event: PiStreamEvent): void {
     if (event.type === "tool_execution_start") this.step(review, describeToolCall(event.toolName, event.args));
-    else if (event.type === "thought") this.deps.feed?.thought(REVIEW_SOURCE, event.text);
+    else if (event.type === "thought") this.deps.feed?.liveThought(REVIEW_SOURCE, event.text, `pr-${review.number}-${review.startedAt}`);
     else if (event.type === "retry") this.step(review, `provider retry ${event.attempt}/${event.maxAttempts}`);
   }
 
@@ -299,6 +299,7 @@ export class PullReviews {
     const ok = review.status === "done";
     const outcome = ok ? `reviewed #${review.number}${review.verdict ? `: ${review.verdict === "changes" ? "request changes" : review.verdict}` : ""}` : `review of #${review.number} ${review.status}${review.error ? ` — ${review.error.split("\n")[0]}` : ""}`;
     this.deps.feed?.end(`pr-${review.number}-${review.startedAt}`, !ok);
+    this.deps.feed?.settleThought(`pr-${review.number}-${review.startedAt}`);
     this.deps.feed?.log(REVIEW_SOURCE, outcome, ok ? "success" : review.status === "cancelled" ? "warning" : "error", review.finishedAt);
     appendMetrics(this.deps.root, this.deps.configDir, [{
       id: `review-${review.number}-${review.startedAt}`,

package/src/lobby/pulls.ts

@@ -4,7 +4,7 @@
  * Like issues, `gh` owns authentication and repository detection; every
  * failure becomes one readable line.
  */
-import { execCommand, gh, type Exec } from "./issues.ts";
+import { gh, type Exec } from "./issues.ts";
 
 export type ChecksState = "passing" | "failing" | "pending";
 
@@ -193,49 +193,6 @@ export async function pullDiff(exec: Exec, cwd: string, number: number, limit =
   return stdout.length > limit ? `${stdout.slice(0, limit)}\n[…the diff continues: ${stdout.length - limit} more characters]` : stdout;
 }
 
-/** A pull request opened for a completed task's branch. */
-export interface CreatedPull {
-  number: number;
-  url: string;
-}
-
-const PUSH_TIMEOUT_MS = 60_000;
-
-async function run(exec: Exec, cwd: string, command: string, args: string[]): Promise<string> {
-  let result: Awaited<ReturnType<Exec>>;
-  try {
-    result = await exec(command, args, { cwd, timeout: PUSH_TIMEOUT_MS });
-  } catch (error) {
-    throw new Error(`${command} could not run — ${(error as Error).message}`);
-  }
-  if (result.code !== 0) throw new Error(result.stderr.trim() || `${command} exited with code ${result.code}`);
-  return result.stdout;
-}
-
-/** `gh pr create` ends with the URL on its own last line; the number is its tail. */
-function parseCreated(stdout: string): CreatedPull {
-  const url = stdout.trim().split("\n").map((line) => line.trim()).filter((line) => /^https?:\/\/\S+$/.test(line)).pop();
-  if (!url) throw new Error("gh pr create printed no pull request URL");
-  const match = /\/pull\/([1-9]\d*)$/.exec(url);
-  const number = Number(match?.[1]);
-  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`gh pr create printed an unreadable URL: ${url}`);
-  return { number, url };
-}
-
-/**
- * Push a finished task's branch and open its pull request, so the work lands
- * in review without the oracle having to remember a second step.
- */
-export async function createPullRequest(options: { exec?: Exec; cwd: string; branch: string; base: string; title: string; body: string }): Promise<CreatedPull> {
-  for (const ref of [options.branch, options.base]) {
-    if (!ref || ref.startsWith("-") || /[\s~^:?*\[\\]|\.\.|@\{|\/\//.test(ref) || /[/.]$/.test(ref)) throw new Error("invalid pull request branch");
-  }
-  const exec = options.exec ?? execCommand;
-  await run(exec, options.cwd, "git", ["push", "-u", "origin", options.branch]);
-  const stdout = await gh(exec, options.cwd, ["pr", "create", "--base", options.base, "--head", options.branch, "--title", options.title, "--body", options.body.slice(0, 60_000)]);
-  return parseCreated(stdout);
-}
-
 /** Lobby state for the Git tab: the list, the open pull request, and what is loading. */
 export class PullsState {
   pulls: PullSummary[] = [];

package/src/lobby/quickfix.ts

@@ -16,6 +16,12 @@ import type { FileHinter } from "../classifier/files.ts";
 import type { Classifier } from "../classifier/classifier.ts";
 import { quickFixSize } from "../classifier/triage.ts";
 import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
+import { existsSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+import type { LintConfig } from "../schemas/configuration.ts";
+import { repositoryTop } from "../execution/git.ts";
+import type { LintExec } from "../execution/lint.ts";
+import { lintFeed, runLintGate } from "../workflow/lint.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
 export const QUICK_FIX_TOOLS: readonly string[] = ["read", "bash", "edit", "write", "grep", "find", "ls"];
@@ -97,6 +103,10 @@ export interface QuickFixDeps {
   classifier?: Classifier;
   /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
   effort?: EffortRouter;
+  /** The lint settings, read as each job finishes: a finished job's touched files are linted, for the activity log only. */
+  lint?: () => LintConfig;
+  /** Runs a linter (tests); the real one otherwise. */
+  lintExec?: LintExec;
 }
 
 export const MAX_JOBS = 30;
@@ -222,7 +232,7 @@ export class QuickFixQueue {
       if (edits?.note(event.toolName, event.args)) job.files = edits.shown();
       this.addStep(job, describeToolCall(event.toolName, event.args), now);
     } else if (event.type === "turn_start") job.turns += 1;
-    else if (event.type === "thought") this.deps.feed?.thought(QUICK_FIX_SOURCE, event.text, now);
+    else if (event.type === "thought") this.deps.feed?.liveThought(QUICK_FIX_SOURCE, event.text, job.id, now);
     else if (event.type === "retry") this.addStep(job, `provider retry ${event.attempt}/${event.maxAttempts}`, now);
     else return;
     this.changed();
@@ -360,14 +370,37 @@ export class QuickFixQueue {
       });
     }
     this.deps.feed?.end(job.id, job.status !== "success");
+    this.deps.feed?.settleThought(job.id);
     const ok = job.status === "success";
     const outcome = ok ? "done" : `${job.status}${job.error ? ` — ${job.error.split("\n")[0]}` : ""}`;
     this.deps.feed?.log(QUICK_FIX_SOURCE, `${outcome}: ${jobTitle(job)}`, ok ? "success" : job.status === "cancelled" ? "warning" : "error", job.finishedAt);
     appendMetrics(this.deps.root, this.deps.configDir, [quickFixMetric(job)]);
     this.deps.notify?.(`bot-lobby quick fix ${outcome}: ${jobTitle(job)}`, ok ? "info" : "warning");
+    if (ok && edited.length > 0) void this.lintAfter(job, edited);
     this.changed();
     this.pump();
   }
+
+  /**
+   * The lint gate's pass over what a quick fix touched (only problems on the
+   * lines it changed are its own): a line in the activity log, never a hold,
+   * as a quick fix has no gate. Lint failing to run says nothing.
+   */
+  private async lintAfter(job: QuickFixJob, edited: readonly string[]): Promise<void> {
+    const config = this.deps.lint?.();
+    if (!config || config.mode === "off") return;
+    try {
+      const top = await repositoryTop(this.deps.cwd);
+      if (!top) return;
+      const files = edited.map((file) => relative(top, file).split("\\").join("/")).filter((file) => file && !file.startsWith("..") && !isAbsolute(file) && existsSync(join(top, file)));
+      const report = await runLintGate({ top, files, config, ...(this.deps.lintExec ? { exec: this.deps.lintExec } : {}) });
+      if (report.state === "skipped") return;
+      const line = lintFeed(job.id, report);
+      this.deps.feed?.log("LINT", line.text, line.kind);
+    } catch {
+      // Advisory: a quick fix is never held or failed for lint.
+    }
+  }
 }
 
 export function quickFixMetric(job: QuickFixJob): MetricRecord {

package/src/lobby/runtime.ts

@@ -9,7 +9,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { appendMetrics, type MetricStatus } from "../state/metrics.ts";
 import { describeToolCall } from "../pi/activity.ts";
-import { currentZenTask, onRunUpdates } from "../pi/ui.ts";
+import { currentZenTask, isMinimized, onRunUpdates } from "../pi/ui.ts";
 import type { WorkspaceInfo } from "../execution/workspace.ts";
 import { basename } from "node:path";
 import { isSubagentProcess } from "../pi/quiet.ts";
@@ -20,7 +20,7 @@ import type { Domain } from "../schemas/agent.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
-import { jobTitle, QuickFixQueue } from "./quickfix.ts";
+import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
 import type { PlanningSession } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
@@ -77,6 +77,21 @@ export async function answerPanel(state: Runtime | undefined = runtime): Promise
   return serviceAnswerPanel(state);
 }
 
+/** What the lobby is running now (a quick fix, a review, a planning round), in words, or undefined. */
+export function lobbyWorkRunning(): string | undefined {
+  const state = runtime;
+  if (!state) return undefined;
+  if (state.quickfix.running) return "A quick fix";
+  if (state.planner?.busy) return "A planning round";
+  if (state.reviews.busy) return "A pull request review";
+  return undefined;
+}
+
+/** Stop the lobby's backend (bot-lobby turned off, or the session ended). */
+export function stopLobbyService(): void {
+  shutdown();
+}
+
 function shutdown(): void {
   const state = runtime;
   if (!state) return;
@@ -165,6 +180,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
     classifier: classifier(),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
+    lint: () => loadConfig().lint,
   });
   runtime = state;
   lobbyService = createLobbyService(state);
@@ -233,7 +249,8 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
     if (runtime) runtime.ctx = ctx;
   };
   pi.on("session_start", (_event, ctx) => {
-    startLobbyService(pi, ctx, configDir);
+    // Off (the default for a new session) runs no lobby until bot-lobby is turned on (see pi/switch.ts).
+    if (!isMinimized()) startLobbyService(pi, ctx, configDir);
   });
   pi.on("session_shutdown", () => shutdown());
   pi.on("ui_prompt_start", () => {

package/src/lobby/service.ts

@@ -10,6 +10,7 @@ import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { loadTask, ownedTask, peekTasks, saveTask } from "../state/persistence.ts";
+import { taskWork } from "../state/work-time.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest, type DeliveryStore } from "../delivery/operations.ts";
 import type { LockIdentity } from "../delivery/lock.ts";
@@ -34,7 +35,7 @@ import { pendingRequest, startRequest } from "../pi/route.ts";
 import { deliverComments, setAuto } from "../pi/owner.ts";
 import { chatFromEntries, lobbyFeed, type ChatEntry } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
-import { launchPi, SessionRegistry, type BackgroundSession, type DialogAnswer, type SessionLauncher } from "./sessions.ts";
+import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, questionnaires, settledQuestions } from "./ask.ts";
 import { askUser } from "../ask/web.ts";
@@ -47,6 +48,7 @@ import type { LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
 import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
 import { pushNotice, type NoticeLevel } from "../webui/notices.ts";
 import type { Runtime } from "./runtime.ts";
+import { findLinters } from "../execution/lint.ts";
 
 function deliveryTask(state: Runtime, taskId: string): Task {
   if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId) || taskId === "." || taskId === "..") throw new Error("Invalid task ID.");
@@ -562,6 +564,7 @@ export function createLobbyService(state: Runtime): LobbyService {
   let appliedMaster = masterKey();
   return {
     projectRoot: () => state.root,
+    linters: () => findLinters(state.root),
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
       const snapshot = taskSnapshot();
@@ -570,6 +573,7 @@ export function createLobbyService(state: Runtime): LobbyService {
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
     tasks: () => peekTasks(state.root, state.configDir),
+    work: (taskId) => taskWork(state.root, state.configDir, taskId),
     deliveryDeliver: (taskId, request: DeliveryRequest) => deliver(request, { cwd: state.root, exec: execCommand }, deliveryStore(state, taskId)),
     deliveryReview: async (taskId) => {
       const task = deliveryTask(state, taskId);

package/src/lobby/session-files.ts

@@ -7,51 +7,7 @@
  * parent, and the text of user and assistant messages (never tool output).
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
-import { chatFromEntries, chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
-
-interface EntryLike {
-  type?: string;
-  id?: string;
-  parentId?: string | null;
-}
-
-/** The entries on the branch that ends at the newest entry, oldest first (a session file is a tree). */
-export function currentBranch(entries: readonly unknown[]): unknown[] {
-  const byId = new Map<string, EntryLike>();
-  let leaf: EntryLike | undefined;
-  for (const entry of entries) {
-    const record = entry as EntryLike;
-    if (!record || typeof record.id !== "string") continue;
-    byId.set(record.id, record);
-    leaf = record;
-  }
-  const branch: unknown[] = [];
-  const seen = new Set<string>();
-  for (let entry = leaf; entry?.id && !seen.has(entry.id); entry = entry.parentId ? byId.get(entry.parentId) : undefined) {
-    seen.add(entry.id);
-    branch.push(entry);
-  }
-  return branch.reverse();
-}
-
-/** Parse a session file's JSON lines, skipping torn ones. */
-export function parseEntries(text: string): unknown[] {
-  const entries: unknown[] = [];
-  for (const line of text.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {
-      // A line being written right now; the next read has it.
-    }
-  }
-  return entries;
-}
-
-/** The conversation a session file holds, as the lobby's chat entries. */
-export function chatFromFile(text: string, max = MAX_CHAT): ChatEntry[] {
-  return chatFromEntries(currentBranch(parseEntries(text)), max).map((line, index) => ({ id: index + 1, at: line.at ?? 0, role: line.role, text: line.text }));
-}
+import { chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
 
 /** What a session log keeps of one entry: its parent, and its conversation lines if it is a message. */
 interface LogNode {

package/src/lobby/split.ts

@@ -202,7 +202,39 @@ function planWithSteps(plan: string, covers: readonly number[], stepCount: numbe
   const lines = plan.split("\n");
   const kept = covers.map((step, index) => found.blocks[step - 1]!.replace(/^(\s*)\d+([.)])/, (_all, indent: string, mark: string) => `${indent}${index + 1}${mark}`));
   const spacer = found.to > found.from && !(lines[found.to - 1] ?? "").trim() ? [""] : [];
-  return [...lines.slice(0, found.from), ...kept.flatMap((block) => block.split("\n")), ...spacer, ...lines.slice(found.to)].join("\n");
+  return [...lines.slice(0, found.from), ...kept.flatMap((block) => block.split("\n")), ...spacer, ...stepDetails(lines.slice(found.to), covers)].join("\n");
+}
+
+/** `### Step 3: …` (or `**Step 3 — …**`): the heading of one step's detail. */
+const DETAIL_HEADING = /^(\s*(?:#{1,6}\s+)?(?:\*\*)?\s*step\s+#?)(\d+)(?!\d)/i;
+const ANY_HEADING = /^\s*(?:(#{1,6})\s+\S.*|\*\*[^*]+\*\*.*)$/;
+
+/** A heading's depth: `#` is 1, a bold line deeper than any `#`. */
+const depth = (line: string): number => ANY_HEADING.exec(line)?.[1]?.length ?? 7;
+
+/**
+ * The lines after a plan's steps list with only the detail of the steps in `covers`, renumbered as
+ * the list was: a step's detail runs from its `Step N` heading to the next heading as deep or deeper.
+ */
+function stepDetails(lines: readonly string[], covers: readonly number[]): string[] {
+  const out: string[] = [];
+  let skipping: number | undefined;
+  for (const line of lines) {
+    const heading = ANY_HEADING.test(line) ? depth(line) : undefined;
+    if (skipping !== undefined && heading !== undefined && heading <= skipping) skipping = undefined;
+    const detail = heading !== undefined ? DETAIL_HEADING.exec(line) : null;
+    if (detail) {
+      const at = covers.indexOf(Number(detail[2]));
+      if (at < 0) {
+        skipping = heading;
+        continue;
+      }
+      out.push(line.replace(DETAIL_HEADING, (_all, lead: string) => `${lead}${at + 1}`));
+      continue;
+    }
+    if (skipping === undefined) out.push(line);
+  }
+  return out;
 }
 
 /** One part's brief: where it sits, what it delivers, then the plan as written with only its own steps. */

package/src/lobby/task-rows.ts

@@ -22,6 +22,8 @@ export interface TaskRow {
   check: CheckState;
   /** Plan steps done, once the task has a plan. */
   progress?: { done: number; total: number };
+  /** How long the task's agents have worked on it, idle time left out (ms, as of the reply). */
+  work?: { workedMs: number; running: boolean };
   /** Who drives it, for tasks other sessions own. */
   owner?: string;
   /** How long ago it finished (finished tasks), was saved (plans) or was archived, as `3h`. */

package/src/master/master.ts

@@ -342,6 +342,8 @@ export interface ReviewerRequest {
   provenance?: string;
   /** What the previous QA round asked for, when there was one: this round verifies it. */
   previousRound?: string;
+  /** The engine's lint result on the touched files and the suppressions the task added. */
+  lint?: string;
   /** Under a task time budget: the gate's time. */
   time?: AgentTime;
   instruction?: string;
@@ -367,6 +369,7 @@ function reviewerContext(request: ReviewerRequest): string {
     request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
     owns.length > 0 ? `Scout findings:\n${summarizeOutcomes(owns, 1200)}` : "",
     request.provenance ? `Who changed each file (bot-lobby's record of every agent's edit and write calls; judge each as your role's Change provenance says):\n${request.provenance}` : "",
+    request.lint ?? "",
     request.time?.note ?? "",
     `Repository changes:\n${request.diff}`,
   ]

package/src/master/research.ts

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
 import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
@@ -39,21 +38,6 @@ export function saveResearchResult(taskDir: string, outcome: ResearchOutcome): v
   writeFileEnsured(researchResultPath(taskDir, outcome.result.domain), JSON.stringify(outcome, null, 2));
 }
 
-/** Re-read persisted research reports for the given domains. */
-export function loadResearchResults(taskDir: string, domains: Domain[]): ResearchOutcome[] {
-  const outcomes: ResearchOutcome[] = [];
-  for (const domain of domains) {
-    const path = researchResultPath(taskDir, domain);
-    if (!existsSync(path)) continue;
-    try {
-      outcomes.push(JSON.parse(readFileSync(path, "utf8")) as ResearchOutcome);
-    } catch {
-      // Corrupted research artifact: skip it rather than failing the workflow.
-    }
-  }
-  return outcomes;
-}
-
 function researchContext(request: ResearchRequest): AgentRequest["context"] {
   return {
     task: request.instruction,

package/src/pi/commands.ts

@@ -17,8 +17,9 @@ import { transition } from "../state/task-state.ts";
 import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
 import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
-import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAsks, waiveQa, type ApprovalChoice } from "../workflow/workflow.ts";
-import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
+import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAsks, waiveLint, waiveQa, type ApprovalChoice } from "../workflow/workflow.ts";
+import { applyStatus, registerRevealShortcut } from "./ui.ts";
+import { isOn, registerSwitch, turnOff, turnOn } from "./switch.ts";
 import { classifierSummary } from "./model-settings.ts";
 import { keyStatus } from "../classifier/instance.ts";
 import { kickoff, startPlannedTask } from "./start-task.ts";
@@ -51,7 +52,7 @@ const HELP = [
   "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
   "/bot-lobby settings         Open the web lobby's Settings: per-agent model, effort and instructions",
   "/bot-lobby config           Show effective configuration",
-  "/bot-lobby minimize|restore   Hide or restore bot-lobby for this session (ctrl+shift+m)",
+  "/bot-lobby on|off           Turn bot-lobby on or off for this session (ctrl+shift+m); a new session starts off",
   "/bot-lobby claim <taskId>    Take ownership of an orphaned task",
   "/bot-lobby auto [on|off]    Auto mode: the oracle drives this session's task without asking (alt+g)",
   "/bot-lobby start-plan PLAN-… [auto]   Start a planned task here; its agreed plan needs no approval",
@@ -61,7 +62,10 @@ const HELP = [
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch", "web"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "on", "off", "minimize", "restore", "claim", "auto", "start-plan", "switch", "web"]);
+
+/** Subcommands that act on a task or open the lobby turn bot-lobby on first; the rest work while it is off. */
+const TURNS_ON = new Set(["lobby", "settings", "resume", "approve", "amend", "decline", "accept", "claim", "auto", "start-plan", "switch", "web"]);
 
 /** `Task-Change-Table-Font-27-09-2026`, or an older `TASK-add-login` id. */
 function isTaskId(value: string | undefined): boolean {
@@ -241,10 +245,12 @@ function acceptWork(pi: ExtensionAPI, ctx: ExtensionCommandContext, configDir: s
     return ctx.ui.notify(`bot-lobby: ${task.id} is still ${task.state}; there is no work to accept yet.`, "warning");
   }
   if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, lastQaAsks(task), "with /bot-lobby accept");
+  if (task.lint?.state === "failing") waiveLint(task, "with /bot-lobby accept");
   saveTask(root, configDir, task);
   applyStatus(ctx, root, configDir);
   ctx.ui.notify(`bot-lobby: ${task.id} accepted as it is; the oracle will complete it.`, "info");
-  const message = `The user accepted ${task.id}'s work as it is (the QA gate is waived). Call orchestrate action=complete now with a short summary that names anything QA still asked for.`;
+  const waived = [task.qaWaiver ? "the QA gate" : "", task.lintWaiver ? "the lint gate" : ""].filter(Boolean);
+  const message = `The user accepted ${task.id}'s work as it is${waived.length ? ` (${waived.join(" and ")} ${waived.length === 1 ? "is" : "are"} waived)` : ""}. Call orchestrate action=complete now with a short summary that names anything QA or lint still asked for.`;
   pi.sendUserMessage(message, ctx.isIdle() ? undefined : { deliverAs: "followUp" });
 }
 
@@ -323,6 +329,7 @@ function autoCommand(ctx: ExtensionCommandContext, configDir: string, value: str
 
 export function registerCommands(pi: ExtensionAPI, configDir: string): void {
   registerRevealShortcut(pi, configDir);
+  registerSwitch(pi, configDir);
   registerWebServer(pi);
   pi.registerCommand("bot-lobby", {
     description: "Structured multi-agent engineering orchestrator",
@@ -334,6 +341,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
     handler: async (args, ctx) => {
       const { sub, rest, restText, auto, budget, budgetError, track, task, isolation } = parseCommand(args ?? "");
       if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
+      // A request, the bare command or anything that drives a task needs bot-lobby on (`web stop` does not).
+      if (!sub || (TURNS_ON.has(sub) && !(sub === "web" && rest[0] === "stop"))) turnOn(pi, ctx, configDir);
       if (!sub) {
         if (!restText) return webCommand(ctx, undefined);
         // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
@@ -371,12 +380,15 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return showKnowledge(ctx, configDir);
         case "settings":
           return webCommand(ctx, undefined);
+        case "off":
         case "minimize":
-          setMinimized(true);
-          return applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir);
+          if (!isOn()) return ctx.ui.notify("bot-lobby is already off.", "info");
+          await turnOff(ctx, configDir);
+          return;
+        case "on":
         case "restore":
-          setMinimized(false);
-          return applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir);
+          if (isOn()) return ctx.ui.notify("bot-lobby is already on.", "info");
+          return turnOn(pi, ctx, configDir);
         case "claim":
           return claimTaskCommand(ctx, configDir, rest[0]);
         case "auto":
@@ -398,6 +410,9 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
 
   pi.registerCommand("bot-lobby-settings", {
     description: "Open the web lobby's settings: per-agent model, effort, and instructions",
-    handler: async (_args, ctx) => webCommand(ctx, undefined),
+    handler: async (_args, ctx) => {
+      turnOn(pi, ctx, configDir);
+      return webCommand(ctx, undefined);
+    },
   });
 }