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

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";
@@ -16,7 +17,7 @@ import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
 import { qaStillDue } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
-import { budgetLine, budgetState, pauseClocks, readBudget, resumeClocks, startClock, stopClocks } from "../state/budget.ts";
+import { budgetLine, budgetState, clockTask, pauseClocks, readBudget, resumeClocks, startClock, stopClocks, turnStarted } from "../state/budget.ts";
 
 /** Tools that wait on the user: the task's clock waits with them. */
 const ASKING_TOOLS: ReadonlySet<string> = new Set(["ask_user_question"]);
@@ -70,15 +71,17 @@ 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);
   });
 
 
-  // A task's time budget counts while the oracle works on it, not while it waits on the user.
+  // A task's work time (and its time budget) counts while the oracle works on it, not while it waits on the user.
   const asking = new Set<string>();
   pi.on("agent_start", (_event, ctx) => {
     if (isSubagentProcess()) return;
+    turnStarted();
     const root = detectProjectRoot(ctx.cwd, configDir);
     const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
     if (task) startClock(root, configDir, task.id);
@@ -90,9 +93,14 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       pauseClocks();
     }
   });
-  pi.on("tool_execution_end", (event) => {
+  pi.on("tool_execution_end", (event, ctx) => {
     if (isSubagentProcess()) return;
     if (asking.delete(event.toolCallId)) resumeClocks();
+    // A task started, finished or taken over within the turn: the clock follows the task the session drives now.
+    if (event.toolName === "orchestrate") {
+      const root = detectProjectRoot(ctx.cwd, configDir);
+      clockTask(root, configDir, activeTask(root, configDir, ctx.sessionManager.getSessionId())?.id);
+    }
   });
   pi.on("agent_end", () => {
     if (isSubagentProcess()) return;

package/src/pi/model-settings.ts

@@ -18,7 +18,6 @@ import { describeKey, jevEndpoint, type StatusSource } from "../classifier/hosts
 
 /** One settings entry: the master or a subagent profile. */
 export type SettingsKind = "master" | SubagentKind;
-export const SETTINGS_KINDS: readonly SettingsKind[] = ["master", ...SUBAGENT_KINDS];
 
 /** The editable fields of one entry; scouts have no thinking and no instructions of their own. */
 export interface EntryView {

package/src/pi/plan-checklist.ts

@@ -89,6 +89,19 @@ function stepSection(lines: readonly string[]): string[] | undefined {
   return body;
 }
 
+/**
+ * The concise list a plan opens its steps with: a `Steps` section that comes
+ * before any `Step N` heading. The plan's detail then follows, often one
+ * `### Step N: …` section per step, and the list stays the checklist.
+ */
+function leadingStepList(lines: readonly string[]): string[] {
+  const section = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  if (section < 0) return [];
+  const heading = lines.findIndex((line) => STEP_HEADING.test(line));
+  if (heading >= 0 && heading < section) return [];
+  return collectSteps(stepSection(lines) ?? [], sectionItem);
+}
+
 /** `Step N` headings, when the plan is structured as one heading per step. */
 function headingSteps(lines: readonly string[]): string[] {
   const found: string[] = [];
@@ -100,13 +113,17 @@ function headingSteps(lines: readonly string[]): string[] {
 }
 
 /**
- * Step texts from a free-form plan, capped. `Step N` headings win; then a
- * `sequence|steps|order` section; then numbered lines; when none exists,
- * top-level bullets are the last resort, so unrelated bullet lists under other
- * headers never leak into the checklist. Only the shallowest items count.
+ * Step texts from a free-form plan, capped. A steps list the plan opens with
+ * wins (its detail may follow under `Step N` headings); then `Step N`
+ * headings; then a `sequence|steps|order` section; then numbered lines; when
+ * none exists, top-level bullets are the last resort, so unrelated bullet
+ * lists under other headers never leak into the checklist. Only the
+ * shallowest items count.
  */
 export function planSteps(plan: string): string[] {
   const lines = plan.split("\n");
+  const leading = leadingStepList(lines);
+  if (leading.length > 0) return leading.slice(0, MAX_PLAN_STEPS);
   const headings = headingSteps(lines);
   if (headings.length > 0) return headings.slice(0, MAX_PLAN_STEPS);
   const section = stepSection(lines);
@@ -119,6 +136,26 @@ export function planSteps(plan: string): string[] {
   return collectSteps(lines, topBulletItem).slice(0, MAX_PLAN_STEPS);
 }
 
+/**
+ * The plan without the steps list it opens with, for reading after the
+ * checklist (which already shows those steps); undefined when the checklist
+ * does not come from such a list, so the plan is read whole.
+ */
+export function planDetails(plan: string): string | undefined {
+  const lines = plan.split("\n");
+  if (leadingStepList(lines).length === 0) return undefined;
+  const heading = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  let to = lines.length;
+  for (let index = heading + 1; index < lines.length; index += 1) {
+    if (HEADER_LINE.test(lines[index]!)) {
+      to = index;
+      break;
+    }
+  }
+  const rest = [...lines.slice(0, heading), ...lines.slice(to)].join("\n").trim();
+  return rest || undefined;
+}
+
 /** Where a plan's steps section sits, and each of its top-level steps whole (its nested lines included). */
 export interface StepBlocks {
   /** The section's body: from this line up to (not including) `to`. */
@@ -239,15 +276,23 @@ function stepScore(step: string, instruction: InstructionIndex): number {
  * named, so "building on step 1, now do step 3" does not jump back to step 1.
  */
 export function explicitStepIndex(instruction: string, count: number): number {
+  return explicitStepRange(instruction, count)?.[1] ?? -1;
+}
+
+/** The 0-based steps an instruction labels itself with, first and last ("Steps 2-4: ..." is 1 to 3); undefined when none. */
+export function explicitStepRange(instruction: string, count: number): [number, number] | undefined {
   const refs = [...instruction.matchAll(STEP_REFERENCE)];
-  if (refs.length === 0) return -1;
+  if (refs.length === 0) return undefined;
   const first = refs[0]!;
   const leading = LEADING_LABEL.test(instruction.slice(0, first.index ?? 0)) ? first : undefined;
   const distinct = new Set(refs.map((ref) => ref[0].toLowerCase().replace(/\s+/g, "")));
   const chosen = leading ?? (distinct.size === 1 ? refs[0] : undefined);
-  if (!chosen) return -1;
-  const last = Math.max(Number(chosen[1]), Number(chosen[2] ?? chosen[1]));
-  return last >= 1 && last <= count ? last - 1 : -1;
+  if (!chosen) return undefined;
+  const a = Number(chosen[1]);
+  const b = Number(chosen[2] ?? chosen[1]);
+  const last = Math.max(a, b);
+  if (last < 1 || last > count) return undefined;
+  return [Math.max(1, Math.min(a, b)) - 1, last - 1];
 }
 
 /**
@@ -345,3 +390,48 @@ export function planChecklist(plan: string, runs: readonly AgentRun[]): PlanStep
   checklistMemo = { plan, runs, steps };
   return steps;
 }
+
+/* -------------------------------------------------------------------------
+ * Step work: how long the workers have worked on each step, and which steps
+ * they are on right now, for the checklist's `active · 1m 12s` marks.
+ * ---------------------------------------------------------------------- */
+
+export interface StepWork {
+  /** Worker time on the step so far, in ms (the running runs up to `now`). */
+  ms: number;
+  /** A worker is on it right now. */
+  active: boolean;
+}
+
+/** The steps a run works on: every step of a range it names, else the step it targets, else the next one still open. */
+function runSteps(steps: readonly string[], instruction: string | undefined, completed: ReadonlySet<number>): number[] {
+  const range = instruction ? explicitStepRange(instruction, steps.length) : undefined;
+  if (range) return Array.from({ length: range[1] - range[0] + 1 }, (_value, offset) => range[0] + offset);
+  const target = targetStep(steps, instruction, completed);
+  const step = target >= 0 ? target : nextOpenStep(steps, completed);
+  return step >= 0 ? [step] : [];
+}
+
+/**
+ * Each step's worker time and whether a worker is on it now, replaying the
+ * runs in start order as the checklist does. A run counts in full toward each
+ * step it works on (a `Steps 2-4` run toward all three), and its success
+ * completes them, so a later run that names no step goes to the next one.
+ */
+export function stepWork(steps: readonly string[], runs: readonly AgentRun[], now = Date.now()): StepWork[] {
+  const work = steps.map(() => ({ ms: 0, active: false }));
+  const completed = new Set<number>();
+  for (const run of byStart(runs)) {
+    if (run.role !== "worker") continue;
+    const covered = runSteps(steps, run.instruction, completed);
+    const start = Date.parse(run.startedAt);
+    const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
+    const ms = Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : 0;
+    for (const index of covered) {
+      work[index]!.ms += ms;
+      if (run.status === "running") work[index]!.active = true;
+    }
+    if (run.status === "success" && covered.length > 0) markThrough(completed, covered[covered.length - 1]!);
+  }
+  return work;
+}

package/src/pi/route.ts

@@ -14,7 +14,6 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { Domain } from "../schemas/agent.ts";
-import type { TaskTriage } from "../schemas/task.ts";
 import { chooseRoute, type RequestRoute } from "../workflow/track.ts";
 import { triageFor } from "../classifier/instance.ts";
 import { ownedTask } from "../state/persistence.ts";

package/src/pi/run-summary.ts

@@ -124,60 +124,3 @@ export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
     ...(entry.error ? { error: entry.error } : {}),
   };
 }
-
-/** Silence after which a working agent reads as "quiet" in the scene. */
-export const QUIET_MS = 45_000;
-
-/** How long a running agent has produced nothing, or 0 when it is not running or has no clock yet. */
-export function quietFor(run: Pick<AgentRun, "status" | "lastEventAt" | "startedAt">, now: number): number {
-  if (run.status !== "running") return 0;
-  const last = run.lastEventAt ?? Date.parse(run.startedAt);
-  const quiet = now - last;
-  return Number.isFinite(quiet) && quiet > 0 ? quiet : 0;
-}
-
-export interface FeedLine {
-  text: string;
-  kind: "info" | "warning";
-}
-
-/** Ticks one working agent holds the feed before it rotates to the next (~3 s at the live clock). */
-export const FEED_ROTATE_TICKS = 12;
-
-/** What one working agent is doing right now, with a warning when something needs attention. */
-function liveFeed(run: AgentRun, now: number): FeedLine {
-  const name = agentName(run);
-  if (run.waitingFor) return { text: `⧗ ${name} waiting for ${run.waitingFor}${run.note ? ` · ${run.note}` : ""}`, kind: "warning" };
-  const quiet = quietFor(run, now);
-  if (quiet >= QUIET_MS) {
-    const doing = run.activity ? ` (last: ${run.activity}${run.detail ? ` ${run.detail}` : ""})` : "";
-    return { text: `! ${name} quiet for ${shortDuration(quiet)}${doing}`, kind: "warning" };
-  }
-  if (run.note && run.noteKind === "warning") return { text: `! ${name} ${run.note}`, kind: "warning" };
-  const parts = [`▸ ${name} ${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`];
-  const turns = run.turns ?? run.usage?.turns;
-  if (turns) parts.push(`turn ${turns}`);
-  if (run.tools) parts.push(`${run.tools} tools`);
-  if (run.usage && run.usage.input + run.usage.output > 0) parts.push(`${tokens(run.usage.input + run.usage.output)} tok`);
-  if (run.note) parts.push(run.note);
-  return { text: parts.join(" · "), kind: "info" };
-}
-
-/**
- * The scene's feed row: a working agent that needs attention first, otherwise
- * the working agents in rotation, otherwise the most recent finished run.
- * Undefined before anything has run.
- */
-export function feedLine(runs: readonly AgentRun[], now: number, tick: number): FeedLine | undefined {
-  const running = runs.filter((run) => run.status === "running");
-  if (running.length > 0) {
-    const lines = running.map((run) => liveFeed(run, now));
-    const warning = lines.find((line) => line.kind === "warning");
-    if (warning) return warning;
-    const index = Math.floor(Math.max(0, tick) / FEED_ROTATE_TICKS) % lines.length;
-    return lines[index];
-  }
-  const last = [...runs].filter((run) => run.finishedAt).sort((a, b) => Date.parse(a.finishedAt!) - Date.parse(b.finishedAt!)).at(-1);
-  if (!last) return undefined;
-  return { text: describeRun(last, now), kind: last.status === "success" && !last.wrappedUp ? "info" : "warning" };
-}

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/agent.ts

@@ -33,7 +33,3 @@ export interface DomainSpec {
 export function isDomain(value: string): value is Domain {
   return (DOMAINS as readonly string[]).includes(value);
 }
-
-export function isRole(value: string): value is Role {
-  return (ROLES as readonly string[]).includes(value);
-}

package/src/schemas/configuration.ts

@@ -13,8 +13,6 @@ export type ThinkingLevelName = (typeof THINKING_LEVELS)[number];
  */
 const INHERIT = "inherit";
 export const INHERIT_MODEL = INHERIT;
-/** Legacy thinking sentinel; configs that still carry it migrate to `DEFAULT_THINKING`. */
-export const INHERIT_THINKING = INHERIT;
 /** Level used for a missing, legacy `inherit` or unknown thinking value. */
 export const DEFAULT_THINKING: ThinkingLevelName = "medium";
 /** Scouts are reconnaissance: always fast, never configurable. */
@@ -92,6 +90,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 +149,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 +231,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 +268,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 +278,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 +342,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 +352,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 +390,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 +459,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(