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

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/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";
@@ -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

@@ -47,6 +47,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 +563,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();

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/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);
+    },
   });
 }

package/src/pi/events.ts

@@ -8,6 +8,7 @@ import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, clearStatus, isMinimized, setMinimized } from "./ui.ts";
+import { startsOn } from "./switch.ts";
 import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
@@ -70,7 +71,8 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
     // Master-only: subagents keep their own --tools allowlist (see quiet.ts).
     if (!isSubagentProcess()) registerQuietTools(pi);
     const root = detectProjectRoot(ctx.cwd, configDir);
-    setMinimized(false);
+    // A new session starts with bot-lobby off unless settings or its own task say otherwise (switch.ts).
+    setMinimized(!isSubagentProcess() && !startsOn(ctx, configDir));
     applyStatus(ctx, root, configDir);
   });
 

package/src/pi/switch.ts

@@ -0,0 +1,69 @@
+/**
+ * Bot-lobby on or off for this pi session. A session starts off, so pi is
+ * plain pi: no oracle prompt, no web lobby, no browser opening. It starts on
+ * only when `lobby.startOn` says so, or when the session already drives a task
+ * 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)
+ * stops with it, so the user is asked first when something is running.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key } from "@earendil-works/pi-tui";
+import { currentLobbyService, lobbyWorkRunning, servesPage, startLobbyService, stopLobbyService } from "../lobby/runtime.ts";
+import { activeTask } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { stopWebServer, webSessionStarted } from "../webui/command.ts";
+import { isSubagentProcess } from "./quiet.ts";
+import { applyStatus, isMinimized, setMinimized } from "./ui.ts";
+
+export const SWITCH_KEY = "ctrl+shift+m";
+
+export function isOn(): boolean {
+  return !isMinimized();
+}
+
+/** Whether a new session starts on: when settings say so, or it owns a task still under way. */
+export function startsOn(ctx: ExtensionContext, configDir: string): boolean {
+  if (loadConfig().lobby.startOn) return true;
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  return Boolean(activeTask(root, configDir, ctx.sessionManager.getSessionId()));
+}
+
+/** Turn bot-lobby on: the oracle's prompt comes back and the web lobby starts (opening the browser if settings say so). */
+export function turnOn(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, quiet = false): void {
+  const was = isOn();
+  setMinimized(false);
+  if (!isSubagentProcess() && servesPage(ctx) && !currentLobbyService()) {
+    startLobbyService(pi, ctx, configDir);
+    webSessionStarted(ctx);
+  }
+  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir);
+  if (!was && !quiet) ctx.ui.notify(`bot-lobby on — ${SWITCH_KEY} or /bot-lobby off turns it off`, "info");
+}
+
+/** Turn bot-lobby off: pi is plain pi until it is turned on again. Returns false when the user kept it on. */
+export async function turnOff(ctx: ExtensionContext, configDir: string): Promise<boolean> {
+  const running = lobbyWorkRunning();
+  if (running && ctx.hasUI && !(await ctx.ui.confirm("Turn bot-lobby off?", `${running} is running in the lobby and stops with it.`))) return false;
+  setMinimized(true);
+  stopLobbyService();
+  await stopWebServer(ctx);
+  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir);
+  ctx.ui.notify(`bot-lobby off — pi is plain pi; ${SWITCH_KEY} or /bot-lobby on turns it on`, "info");
+  return true;
+}
+
+export async function toggleBotLobby(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string): Promise<void> {
+  if (isOn()) await turnOff(ctx, configDir);
+  else turnOn(pi, ctx, configDir);
+}
+
+/** Ctrl+Shift+M switches bot-lobby on and off for this session. */
+export function registerSwitch(pi: ExtensionAPI, configDir: string): void {
+  if (isSubagentProcess()) return;
+  pi.registerShortcut(Key.ctrlShift("m"), {
+    description: "bot-lobby: turn bot-lobby on or off for this session",
+    handler: (ctx) => toggleBotLobby(pi, ctx, configDir),
+  });
+}

package/src/pi/tools.ts

@@ -15,6 +15,8 @@ import { unescapeBreaks } from "../lobby/blocks.ts";
 import { isQuiet } from "./quiet.ts";
 import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
+import { lintFeed } from "../workflow/lint.ts";
+import { lobbyFeed } from "../lobby/feed.ts";
 import {
   ORCHESTRATE_ACTIONS,
   runWorkflowAction,
@@ -133,6 +135,11 @@ export function workflowDeps(
     notify: (message, level = "info") => {
       if (hasUI) ctx.ui.notify(message, level);
     },
+    // Each new lint result on a task's touched files is a line in the lobby's activity log.
+    onLint: (taskId, report) => {
+      const line = lintFeed(taskId, report);
+      lobbyFeed.log("LINT", line.text, line.kind);
+    },
   };
 }
 

package/src/pi/ui.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key } from "@earendil-works/pi-tui";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { Task } from "../schemas/task.ts";
 import { activeTask } from "../state/persistence.ts";
@@ -17,7 +16,7 @@ export function summarizeRun(run: AgentRun): string {
 /** One-line footer text, always carrying the quiet-mode hint. */
 export function statusText(task: Task | undefined, minimized = false): string {
   const mode = isQuiet() ? "tools hidden (alt+t)" : "tools shown";
-  if (minimized) return `bot-lobby minimized (ctrl+shift+m) · ${mode}`;
+  if (minimized) return `bot-lobby off (ctrl+shift+m) · ${mode}`;
   if (!task) return `bot-lobby · ${mode}`;
   return `bot-lobby ${task.id} · ${task.paused ? `${task.state} (paused)` : task.state} · ${mode}`;
 }
@@ -73,7 +72,7 @@ function setZenState(task: Task | undefined, live: AgentRun[]): void {
   zenState = { task, live, runs: mergeRuns(persistedRuns(task), live) };
 }
 
-/** Per-session standard-pi mode: the Master prompt is hidden but ownership stays. */
+/** Bot-lobby off for this session (plain pi): the Master prompt is hidden but ownership stays (see switch.ts). */
 let minimized = false;
 
 export function isMinimized(): boolean {
@@ -84,13 +83,6 @@ export function setMinimized(value: boolean): void {
   minimized = value;
 }
 
-/** Flip minimize/restore and refresh the footer; the session is unchanged. */
-export function toggleMinimized(ctx: ExtensionContext, configDir: string): void {
-  setMinimized(!minimized);
-  applyStatus(ctx, detectProjectRoot(ctx.cwd, configDir), configDir, zenState.live);
-  ctx.ui.notify(minimized ? "bot-lobby minimized — ctrl+shift+m or /bot-lobby restore to return" : "bot-lobby restored", "info");
-}
-
 /**
  * Refresh the footer to match the task on disk. Runs are merged into the
  * retained set for the same task because each `orchestrate` call reports only its
@@ -144,10 +136,6 @@ export function registerRevealShortcut(pi: ExtensionAPI, configDir: string): voi
     description: "bot-lobby: reveal or hide built-in tool rows",
     handler: (ctx) => revealTools(ctx, configDir),
   });
-  pi.registerShortcut(Key.ctrlShift("m"), {
-    description: "bot-lobby: minimize or restore bot-lobby for this session",
-    handler: (ctx) => toggleMinimized(ctx, configDir),
-  });
 }
 
 function revealTools(ctx: ExtensionContext, configDir: string): void {

package/src/schemas/configuration.ts

@@ -92,6 +92,29 @@ export interface WorkflowConfig {
   gitIsolation: GitIsolation;
 }
 
+/**
+ * The lint gate: off; advise (the oracle and QA see what the project's own
+ * linter finds in the files the task's agents touched); or block (errors on
+ * the lines the task changed also hold completion until they are fixed or
+ * the user accepts the work as it is).
+ */
+export const LINT_MODES = ["off", "advise", "block"] as const;
+export type LintMode = (typeof LINT_MODES)[number];
+
+export function isLintMode(value: unknown): value is LintMode {
+  return typeof value === "string" && (LINT_MODES as readonly string[]).includes(value);
+}
+
+export interface LintConfig {
+  mode: LintMode;
+  /** A command of your own, run without a shell from the repository's top; `{files}` stands for the touched files (they are appended when it is absent). Empty: the project's own linters are found (ESLint, Biome, Oxlint, Ruff). */
+  command: string;
+  /** Which touched files the command is given, by extension (`.ts`, `.py`); empty gives it every one. */
+  extensions: string[];
+  /** Time limit for one linter run. */
+  timeoutMs: number;
+}
+
 export interface KnowledgeConfig {
   compactionThreshold: number;
   backupCount: number;
@@ -128,6 +151,8 @@ export interface LobbyConfig {
   planningPanel: PanelMember[];
   /** Show the GitHub Issues tab (off for now). */
   issues: boolean;
+  /** Bot-lobby is on when pi starts; off (the default), pi starts as plain pi until ctrl+shift+m or /bot-lobby on. */
+  startOn: boolean;
   /** Which panes the Lobby tab shows. */
   panels: Record<LobbyPanel, boolean>;
   /** Key overrides by action name, e.g. `{ "search": "alt+f" }`. */
@@ -208,6 +233,8 @@ export interface BotLobbyConfig {
   /** The task planner that grills the user until a plan is clear; `timeoutMs` bounds one turn. */
   planner: AgentModelConfig;
   workflow: WorkflowConfig;
+  /** The engine lints the files a task's agents touched, after each step, before QA and at completion. */
+  lint: LintConfig;
   knowledge: KnowledgeConfig;
   lobby: LobbyConfig;
   classifier: ClassifierConfig;
@@ -243,6 +270,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     routeQuickFixes: true,
     gitIsolation: "off",
   },
+  lint: { mode: "advise", command: "", extensions: [], timeoutMs: 2 * 60 * 1000 },
   knowledge: {
     compactionThreshold: 20000,
     backupCount: 1,
@@ -252,6 +280,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
   lobby: {
     planningPanel: [...PANEL_MEMBERS],
     issues: false,
+    startOn: false,
     panels: { conversation: true, activity: true, thinking: true },
     keys: {},
     maxPlanningRounds: 5,
@@ -315,7 +344,7 @@ function flag(value: unknown, fallback: boolean): boolean {
 }
 
 function normalizeLobby(value: unknown): LobbyConfig {
-  const source = value as { planningPanel?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; maxPlanningRounds?: unknown; splitPlanAbove?: unknown; web?: unknown } | undefined;
+  const source = value as { planningPanel?: unknown; issues?: unknown; startOn?: unknown; panels?: unknown; keys?: unknown; maxPlanningRounds?: unknown; splitPlanAbove?: unknown; web?: unknown } | undefined;
   const defaults = DEFAULT_CONFIG.lobby;
   const panel = Array.isArray(source?.planningPanel)
     ? [...new Set(source.planningPanel.filter((entry): entry is PanelMember => typeof entry === "string" && isPanelMember(entry)))]
@@ -325,6 +354,7 @@ function normalizeLobby(value: unknown): LobbyConfig {
   return {
     planningPanel: PANEL_MEMBERS.filter((member) => panel.includes(member)),
     issues: flag(source?.issues, defaults.issues),
+    startOn: flag(source?.startOn, defaults.startOn),
     panels: Object.fromEntries(LOBBY_PANELS.map((name) => [name, flag(panels[name], defaults.panels[name])])) as Record<LobbyPanel, boolean>,
     keys: Object.fromEntries(Object.entries(keys).filter((entry): entry is [string, string] => typeof entry[1] === "string" && entry[1].trim().length > 0)),
     maxPlanningRounds: roundLimit(source?.maxPlanningRounds, defaults.maxPlanningRounds),
@@ -362,6 +392,25 @@ function text(value: unknown, fallback: string): string {
   return typeof value === "string" ? value.trim() : fallback;
 }
 
+/** `.ts`, `TSX` and `*.py` all read as `.ts`, `.tsx`, `.py`. */
+function extension(value: string): string {
+  const bare = value.trim().replace(/^\*/, "").replace(/^\./, "").toLowerCase();
+  return bare ? `.${bare}` : "";
+}
+
+function normalizeLint(value: unknown): LintConfig {
+  const source = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
+  const defaults = DEFAULT_CONFIG.lint;
+  const extensions = Array.isArray(source.extensions) ? source.extensions.filter((entry): entry is string => typeof entry === "string").map(extension).filter(Boolean) : [...defaults.extensions];
+  const timeout = positive(source.timeoutMs);
+  return {
+    mode: isLintMode(source.mode) ? source.mode : defaults.mode,
+    command: text(source.command, defaults.command),
+    extensions: [...new Set(extensions)],
+    timeoutMs: timeout ? Math.min(30 * 60 * 1000, Math.round(timeout)) : defaults.timeoutMs,
+  };
+}
+
 function normalizeClassifier(value: unknown): ClassifierConfig {
   const source = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
   const defaults = DEFAULT_CONFIG.classifier;
@@ -412,6 +461,7 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
     quickFix: normalizeAgent(DEFAULT_CONFIG.quickFix, src.quickFix as Partial<AgentModelConfig> | undefined),
     planner: normalizeAgent(DEFAULT_CONFIG.planner, src.planner as Partial<AgentModelConfig> | undefined),
     workflow,
+    lint: normalizeLint(src.lint),
     knowledge,
     lobby: normalizeLobby(src.lobby),
     classifier: normalizeClassifier(src.classifier),

package/src/schemas/lint.ts

@@ -0,0 +1,55 @@
+/**
+ * What the lint gate found: per linter run, and for the task as a whole. The
+ * engine records the last report on the task, so completion, QA and the
+ * lobby read the same result, and an unchanged tree is not linted twice.
+ */
+
+export type LintState = "passing" | "failing" | "unavailable" | "skipped";
+
+export interface LintFinding {
+  /** Repository-relative, with forward slashes. */
+  file: string;
+  line?: number;
+  column?: number;
+  rule?: string;
+  message: string;
+  severity: "error" | "warning";
+  /** On a line the task changed (or in a file it created); false for what was already there. */
+  fresh?: boolean;
+}
+
+export interface LintRun {
+  /** ESLint, Biome, Oxlint, Ruff, or the command from Settings. */
+  tool: string;
+  /** The folder it ran in, repository-relative ("" at the top). */
+  folder: string;
+  files: string[];
+  state: "passing" | "failing" | "unavailable";
+  errors: number;
+  warnings: number;
+  /** At most `MAX_FINDINGS` of them, those on changed lines first; the counts stay whole. */
+  findings: LintFinding[];
+  /** The tail of what it printed when that could not be read as findings, or why it could not run. */
+  output?: string;
+  ms: number;
+}
+
+export interface LintReport {
+  at: string;
+  /** failing: errors on lines the task changed; passing: none (what was already there never fails it). */
+  state: LintState;
+  /** The touched files it covered, repository-relative. */
+  files: string[];
+  runs: LintRun[];
+  errors: number;
+  warnings: number;
+  /** Of those, on lines the task changed or in files it created. */
+  freshErrors: number;
+  freshWarnings: number;
+  /** Lint suppressions and lint-config changes the task added, one line each, for QA to judge. */
+  suppressions: string[];
+  /** Why nothing ran, when nothing did. */
+  note?: string;
+  /** The touched files as they stood and the settings: an equal key means an equal result. */
+  fingerprint: string;
+}

package/src/schemas/task.ts

@@ -1,3 +1,4 @@
+import type { LintReport } from "./lint.ts";
 import type { Domain, Role } from "./agent.ts";
 import type { Delivery } from "../delivery/types.ts";
 
@@ -224,6 +225,10 @@ export interface Task {
   qaWaiver?: QaWaiver;
   /** The git branch (or worktree) made for this task, when isolation was on as it started. */
   git?: TaskGit;
+  /** The lint gate's last report on the files this task's agents touched. */
+  lint?: LintReport;
+  /** Set only by the user: the work is accepted with the lint errors it has, so the task may complete. */
+  lintWaiver?: { at: string };
 }
 
 export function createTask(

package/src/state/changes.ts

@@ -142,6 +142,8 @@ export interface FileProvenance {
   notes: string[];
   /** The quick fixes that edited it. */
   quickFixes: string[];
+  /** This task's domains whose workers edited it. */
+  domains?: Domain[];
 }
 
 const DOMAIN_LABELS: Record<string, string> = { backend: "DEV", designer: "DESIGN", qa: "QA" };
@@ -180,6 +182,7 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
     const kinds: Provenance[] = [];
     const notes: string[] = [];
     const quickFixes: string[] = [];
+    const domains: Domain[] = [];
     const add = (kind: Provenance, note: string) => {
       if (!kinds.includes(kind)) kinds.push(kind);
       if (!notes.includes(note)) notes.push(note);
@@ -188,12 +191,15 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
       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);
-      } else if (record.taskId === task.id) add("planned", `planned: ${DOMAIN_LABELS[record.domain ?? ""] ?? record.domain ?? "worker"} — ${clip(record.what)}`);
+      } 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);
+      }
       else add("other-task", `another task's worker (${record.taskId ?? "unknown task"}): ${clip(record.what)}`);
     }
     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 };
+    return { path, kinds, notes, quickFixes, ...(domains.length ? { domains } : {}) };
   });
 }