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

package/src/webui/api/index.ts

@@ -23,7 +23,7 @@ import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
 import { issuesCreate, issuesGet, issuesList } from "./issues.ts";
 import { sessionsAnswer, sessionsChat, sessionsList, sessionsMessage, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
-import { settingsGet, settingsSet } from "./settings.ts";
+import { settingsGet, settingsLinters, settingsSet } from "./settings.ts";
 import { noticeText, pushNotice } from "../notices.ts";
 
 /** What a handler reads besides the request body. */
@@ -367,6 +367,7 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ patch: Type.Object({}, { additionalProperties: true }) }, { additionalProperties: false }),
     run: (body, ctx) => settingsSet(body as { patch: Record<string, unknown> }, ctx),
   };
+  routes["settings.linters"] = { schema: Empty, run: (_body, ctx) => settingsLinters(ctx) };
   return routes;
 }
 

package/src/webui/api/knowledge.ts

@@ -7,7 +7,9 @@
  */
 import type { KnowledgeAgent } from "../../knowledge/paths.ts";
 import type { EntryRef } from "../../lobby/knowledge.ts";
-import type { KnowledgeFileInfo, KnowledgeViewData } from "../protocol.ts";
+import type { KnowledgeAgentName, KnowledgeFileInfo, KnowledgeViewData } from "../protocol.ts";
+import { INHERIT_MODEL, type BotLobbyConfig } from "../../schemas/configuration.ts";
+import { loadConfig } from "../../state/project.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
 
@@ -31,8 +33,14 @@ interface RefBody extends FileBody {
 }
 
 /** Every agent's files with their size and note counts, in tab order. */
-export function knowledgeFiles(ctx: ApiContext): { files: KnowledgeFileInfo[] } {
-  return { files: ctx.service.knowledge.files() };
+export function knowledgeFiles(ctx: ApiContext): { files: KnowledgeFileInfo[]; models: Record<KnowledgeAgentName, string> } {
+  return { files: ctx.service.knowledge.files(), models: agentModels(ctx.service.config?.() ?? loadConfig()) };
+}
+
+/** The model each knowledge-keeping agent runs on, as the tree names it ("session model" when none is pinned). */
+export function agentModels(config: BotLobbyConfig): Record<KnowledgeAgentName, string> {
+  const named = (model: string) => (model === INHERIT_MODEL || !model.trim() ? "session model" : model);
+  return { master: named(config.master.model), designer: named(config.agents.designer.model), backend: named(config.agents.backend.model), qa: named(config.agents.qa.model) };
 }
 
 /** One file as entries with their notes. */

package/src/webui/api/settings.ts

@@ -10,7 +10,7 @@ import { lobbyTopics } from "../../lobby/topics.ts";
 import { prefillModels } from "../../pi/model-settings.ts";
 import { kindLabel } from "../../pi/model-support.ts";
 import { pushNotice } from "../notices.ts";
-import type { SettingsInfo } from "../protocol.ts";
+import type { SettingsInfo, SettingsLinter } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
 
@@ -93,6 +93,11 @@ export function settingsGet(ctx: ApiContext): SettingsInfo {
   return { config: stripSecrets(config), models: ctx.service.models?.() ?? [] };
 }
 
+/** The linters the project configures (its top and a few folders below), and whether each is installed. */
+export function settingsLinters(ctx: ApiContext): { linters: SettingsLinter[] } {
+  return { linters: ctx.service.linters?.() ?? [] };
+}
+
 /** Merge, normalise and save the patch; the lobby rereads the config. */
 export function settingsSet(body: { patch: Record<string, unknown> }, ctx: ApiContext): { config: BotLobbyConfig } {
   checkPort(body.patch);

package/src/webui/command.ts

@@ -119,6 +119,16 @@ function resetCommand(ctx: ExtensionCommandContext): void {
   ctx.ui.notify(`bot-lobby web: the link changed: ${link}`, "info");
 }
 
+/** Close the page's server when bot-lobby is turned off; quiet, and nothing when it is not running. */
+export async function stopWebServer(ctx: ExtensionContext): Promise<void> {
+  const running = currentWebServer();
+  if (!running) return;
+  await running.close();
+  latestLink = undefined;
+  heartbeat();
+  showAddress(ctx, undefined);
+}
+
 /** Run one `web` subcommand; a failure is a notice, never a throw. */
 export async function webCommand(ctx: ExtensionCommandContext, word: string | undefined, deps?: WebCommandDeps): Promise<void> {
   const action = webAction(word);
@@ -137,9 +147,10 @@ export async function webCommand(ctx: ExtensionCommandContext, word: string | un
 }
 
 /**
- * On `session_start`: follow the fresh lobby service, and start the server
- * (the first time) with the browser opening on it. The page is always on in
- * an interactive session; a subagent or a one-shot run serves nothing.
+ * On `session_start` (and when bot-lobby is turned on): follow the fresh
+ * lobby service, and start the server (the first time) with the browser
+ * opening on it. The page runs while bot-lobby is on in an interactive
+ * session; off, a subagent or a one-shot run serves nothing.
  */
 export function webSessionStarted(ctx: ExtensionContext, deps?: WebCommandDeps): void {
   if (isSubagentProcess() || !servesPage(ctx)) return;

package/src/webui/dev/fake-service.ts

@@ -447,6 +447,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     sessionName: () => fixture.status.sessionName,
     masterBusy: () => fixture.status.busy,
     config: () => config,
+    linters: () => fixture.settings?.linters ?? [{ tool: "ESLint", folder: "", installed: true }, { tool: "Ruff", folder: "services/api", installed: false }],
     saveConfig: (next: BotLobbyConfig) => {
       config = next;
     },

package/src/webui/dev/fixtures.ts

@@ -20,6 +20,7 @@ export const SCENARIOS = [
   "question",
   "questions3",
   "issues",
+  "mockups",
 ] as const;
 
 export type ScenarioName = (typeof SCENARIOS)[number];
@@ -58,7 +59,7 @@ export interface ScenarioFixture {
   /** Streamed back (in deltas) after `lobby.send`. */
   oracleReply: string;
   /** The Settings page's mock: a partial config merged over the defaults, and the models Pi offers. */
-  settings?: { config?: Record<string, unknown>; models?: Array<{ id: string; label: string; thinkingLevels: string[] }> };
+  settings?: { config?: Record<string, unknown>; models?: Array<{ id: string; label: string; thinkingLevels: string[] }>; linters?: Array<{ tool: string; folder: string; installed: boolean }> };
   /** Opened through `promptHub` shortly after a send, if any. */
   questionAfterSend: FixturePrompt | null;
   /** Tasks backing `tasks.list` (absent means none). */

package/src/webui/protocol.ts

@@ -159,6 +159,14 @@ export interface SettingsModelInfo {
   thinkingLevels: string[];
 }
 
+/** A linter the project configures (`settings.linters`): which, in which folder, and whether it is installed to run. */
+export interface SettingsLinter {
+  tool: string;
+  /** Repository-relative; "" is the top. */
+  folder: string;
+  installed: boolean;
+}
+
 /** `settings.get`: the effective config (never a secret) and the models Pi offers. */
 export interface SettingsInfo {
   config: BotLobbyConfig;
@@ -555,7 +563,7 @@ export interface Api {
   "quickfix.runAnyway": { request: { id: string }; result: { notice: string } };
   "quickfix.movedToTask": { request: { id: string }; result: { notice: string; key?: string } };
   "metrics.get": { request: { groupBy: "model" | "model-kind"; query?: string }; result: MetricsData };
-  "knowledge.files": { request: Record<string, never>; result: { files: KnowledgeFileInfo[] } };
+  "knowledge.files": { request: Record<string, never>; result: { files: KnowledgeFileInfo[]; models?: Partial<Record<KnowledgeAgentName, string>> } };
   "knowledge.open": { request: { agent: KnowledgeAgentName; file: string }; result: { view: KnowledgeViewData } };
   "knowledge.edit": { request: { agent: KnowledgeAgentName; file: string; ref: EntryRefInfo; text: string }; result: { notice: string } };
   "knowledge.add": { request: { agent: KnowledgeAgentName; file: string; ref?: EntryRefInfo; text: string }; result: { notice: string } };
@@ -583,6 +591,7 @@ export interface Api {
   "issues.create": { request: { text: string }; result: { notice: string } };
   "settings.get": { request: Record<string, never>; result: SettingsInfo };
   "settings.set": { request: { patch: Record<string, unknown> }; result: { config: BotLobbyConfig } };
+  "settings.linters": { request: Record<string, never>; result: { linters: SettingsLinter[] } };
 }
 
 export type ApiName = keyof Api;

package/src/workflow/lint.ts

@@ -0,0 +1,221 @@
+/**
+ * The lint gate. The engine lints the files a task's agents touched (and only
+ * those) with the project's own linter, after every worker step, before QA and
+ * at completion, so what the oracle and QA are told is a check the engine ran,
+ * not an agent's word. Every file is linted whole, but only problems on the
+ * lines the task changed (or in files it created) are the task's: what was
+ * already there is reported and never holds it. In block mode new errors hold
+ * completion; in advise mode they are reported only. Lint suppressions and
+ * lint-config changes the task added are listed for QA, which cannot edit, to
+ * judge: a worker cannot quietly get past the gate.
+ */
+import { basename } from "node:path";
+import type { LintConfig, LintMode } from "../schemas/configuration.ts";
+import type { LintFinding, LintReport, LintRun } from "../schemas/lint.ts";
+import { addedLines, type AddedLines } from "../execution/git.ts";
+import { execLint, lintFingerprint, MAX_FINDINGS, planLint, runPlan, type LintExec } from "../execution/lint.ts";
+import { truncate } from "../text.ts";
+
+/** Comments and attributes that switch a linter or type checker off. */
+const SUPPRESSION = /\b(?:eslint-disable(?:-next-line|-line)?|eslint-enable|oxlint-disable(?:-next-line|-line)?|biome-ignore(?:-all|-start)?|deno-lint-ignore(?:-file)?|stylelint-disable(?:-next-line|-line)?|jshint\s+ignore)\b|@ts-(?:ignore|nocheck|expect-error)\b|#\s*(?:noqa|type:\s*ignore|pylint:\s*disable|ruff:\s*noqa|rubocop:\s*disable)\b|\/\/\s*nolint\b|NOLINT(?:NEXTLINE)?\b|@SuppressWarnings\b|#!?\[allow\(/;
+
+/** Files that decide what a linter or the type checker checks. */
+const LINT_CONFIG = /^(?:eslint\.config\.[cm]?[jt]s|\.eslintrc(?:\.(?:js|cjs|json|ya?ml))?|\.eslintignore|biome\.jsonc?|\.oxlintrc\.json|oxlint\.config\.ts|\.oxlintignore|ruff\.toml|\.ruff\.toml|\.flake8|\.pylintrc|\.golangci\.(?:ya?ml|toml|json)|\.rubocop\.yml|\.stylelintrc(?:\.\w+)?|tsconfig(?:\.[\w-]+)?\.json)$/;
+/** Shared config files that count only when the added lines touch a linter. */
+const SHARED_CONFIG = /^(?:package\.json|pyproject\.toml|setup\.cfg|tox\.ini)$/;
+const LINT_WORDS = /lint|eslint|biome|oxlint|ruff|flake8|pylint|noqa|strict/i;
+
+/** Suppressions shown to QA. */
+const MAX_SUPPRESSIONS = 40;
+
+/**
+ * Every lint suppression and lint-config change among the lines the task
+ * added: `src/a.ts:3 — // eslint-disable-next-line no-explicit-any`, or
+ * `eslint.config.js — lint config changed`.
+ */
+export function lintSuppressions(added: AddedLines | undefined, files: readonly string[]): string[] {
+  const out: string[] = [];
+  const configs = new Set<string>();
+  for (const file of files) if (LINT_CONFIG.test(basename(file))) configs.add(file);
+  for (const entry of added?.text ?? []) {
+    if (SHARED_CONFIG.test(basename(entry.file)) && LINT_WORDS.test(entry.text)) configs.add(entry.file);
+    else if (SUPPRESSION.test(entry.text) && !LINT_CONFIG.test(basename(entry.file))) out.push(`${entry.file}:${entry.line} — ${truncate(entry.text.trim(), 160)}`);
+  }
+  return [...[...configs].sort().map((file) => `${file} — lint or type-check config changed`), ...out].slice(0, MAX_SUPPRESSIONS);
+}
+
+/** Whether a finding sits on a line the task changed: always in a file it created, and when git cannot say. */
+function fresh(finding: LintFinding, added: AddedLines | undefined): boolean {
+  if (!added || added.whole.has(finding.file)) return true;
+  if (!finding.line) return true;
+  return added.lines.get(finding.file)?.has(finding.line) ?? false;
+}
+
+/** New ones first, errors before warnings, then by place. */
+function order(a: LintFinding, b: LintFinding): number {
+  return Number(Boolean(b.fresh)) - Number(Boolean(a.fresh)) || Number(b.severity === "error") - Number(a.severity === "error") || a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0);
+}
+
+export interface LintGateInput {
+  /** The repository's top folder; `files` are relative to it. */
+  top: string;
+  /** The files the task's agents touched. */
+  files: readonly string[];
+  /** The commit the task's work is measured from (HEAD when absent). */
+  base?: string;
+  config: LintConfig;
+  /** The last report: reused when the files and settings are unchanged. */
+  previous?: LintReport;
+  exec?: LintExec;
+  signal?: AbortSignal;
+  now?: () => Date;
+}
+
+/** Lint the touched files, or reuse the last report when nothing it covers has changed since. */
+export async function runLintGate(input: LintGateInput): Promise<LintReport> {
+  const at = (input.now?.() ?? new Date()).toISOString();
+  const files = [...new Set(input.files)].sort();
+  const fingerprint = lintFingerprint(input.top, files, input.config);
+  const previous = input.previous;
+  if (previous && previous.fingerprint === fingerprint && (previous.state === "passing" || previous.state === "failing")) return previous;
+  const empty = (note: string): LintReport => ({ at, state: "skipped", files, runs: [], errors: 0, warnings: 0, freshErrors: 0, freshWarnings: 0, suppressions: [], note, fingerprint });
+  if (files.length === 0) return empty("no files touched yet");
+  const added = await addedLines(input.top, input.base, files);
+  const suppressions = lintSuppressions(added, files);
+  const plans = planLint(input.top, files, input.config);
+  if (plans.length === 0) return { ...empty(input.config.command.trim() ? "none of the touched files is of a type the lint command takes" : "no linter is configured for the touched files"), suppressions };
+  const runs: LintRun[] = [];
+  let freshErrors = 0;
+  let freshWarnings = 0;
+  for (const plan of plans) {
+    const run = await runPlan(plan, input.top, input.config, input.exec ?? execLint, input.signal);
+    const findings = run.findings.map((finding) => ({ ...finding, fresh: fresh(finding, added) })).sort(order);
+    const counts = countFresh(findings);
+    freshErrors += counts.freshErrors;
+    freshWarnings += counts.freshWarnings;
+    runs.push({ ...run, findings: findings.slice(0, MAX_FINDINGS) });
+  }
+  const ran = runs.filter((run) => run.state !== "unavailable");
+  return {
+    at,
+    state: freshErrors > 0 ? "failing" : ran.length === 0 ? "unavailable" : "passing",
+    files,
+    runs,
+    errors: runs.reduce((total, run) => total + run.errors, 0),
+    warnings: runs.reduce((total, run) => total + run.warnings, 0),
+    freshErrors,
+    freshWarnings,
+    suppressions,
+    fingerprint,
+  };
+}
+
+interface FreshCounts {
+  freshErrors: number;
+  freshWarnings: number;
+}
+
+function countFresh(findings: readonly LintFinding[]): FreshCounts {
+  const mine = findings.filter((finding) => finding.fresh);
+  const errors = mine.filter((finding) => finding.severity === "error").length;
+  return { freshErrors: errors, freshWarnings: mine.length - errors };
+}
+
+/** True when the report holds completion: block mode, new errors, and the user has not accepted the work as it is. */
+export function lintHolds(report: LintReport | undefined, mode: LintMode, waived: boolean): boolean {
+  return mode === "block" && report?.state === "failing" && !waived;
+}
+
+const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`;
+
+/** `ESLint, Ruff` */
+function tools(report: LintReport): string {
+  return [...new Set(report.runs.map((run) => run.tool))].join(", ");
+}
+
+/** One line: `ESLint on 3 touched files: 2 new errors, 1 new warning (4 more already there)`. */
+export function lintSummary(report: LintReport): string {
+  if (report.state === "skipped") return `Lint: ${report.note ?? "nothing to lint"}.`;
+  const head = `${tools(report)} on ${plural(report.files.length, "touched file")}`;
+  if (report.state === "unavailable") return `${head}: could not run.`;
+  const old = report.errors + report.warnings - report.freshErrors - report.freshWarnings;
+  const news = [report.freshErrors ? plural(report.freshErrors, "new error") : "", report.freshWarnings ? plural(report.freshWarnings, "new warning") : ""].filter(Boolean).join(", ");
+  return `${head}: ${news || "no new problems"}${old > 0 ? ` (${plural(old, "problem")} already there before this task)` : ""}.`;
+}
+
+function place(finding: LintFinding): string {
+  return `${finding.file}${finding.line ? `:${finding.line}${finding.column ? `:${finding.column}` : ""}` : ""}`;
+}
+
+function findingLine(finding: LintFinding, owners?: ReadonlyMap<string, string>): string {
+  const owner = owners?.get(finding.file);
+  return `- ${place(finding)}${finding.rule ? ` [${finding.rule}]` : ""} ${truncate(finding.message.replace(/\s+/g, " "), 200)} — ${finding.severity}${owner ? ` (${owner})` : ""}`;
+}
+
+function newFindings(report: LintReport, max: number): LintFinding[] {
+  return report.runs.flatMap((run) => run.findings.filter((finding) => finding.fresh)).slice(0, max);
+}
+
+function cannotRun(report: LintReport): string[] {
+  return report.runs.filter((run) => run.state === "unavailable").map((run) => `${run.tool}${run.folder ? ` (${run.folder}/)` : ""}: ${truncate((run.output ?? "could not run").split("\n")[0]!, 200)}`);
+}
+
+/**
+ * What the oracle is told after a step, before QA's verdict and at completion:
+ * the new problems with the domain that touched each file, what to do about
+ * them for the mode, the suppressions the task added, and what could not run.
+ * Empty when there is nothing to say (no linter, nothing touched).
+ */
+export function lintNote(report: LintReport | undefined, mode: LintMode, owners?: ReadonlyMap<string, string>): string {
+  if (!report || mode === "off" || report.state === "skipped") return "";
+  const lines = [`Lint — ${lintSummary(report)}`];
+  if (report.state === "failing" || report.freshWarnings > 0) {
+    lines.push(...newFindings(report, 20).map((finding) => findingLine(finding, owners)));
+    lines.push(
+      mode === "block" && report.state === "failing"
+        ? "Completion is held until the new errors are fixed: delegate each fix to the domain that touched the file, and have it fix the cause, never silence the rule (QA reads every new suppression as a finding)."
+        : "Advisory: have the domain that touched each file fix the new ones, or tell the user why they stay. Never have a rule silenced to pass.",
+    );
+  }
+  const blocked = cannotRun(report);
+  if (blocked.length > 0) lines.push(`Could not run, so nothing is held for it: ${blocked.join("; ")}.`);
+  if (report.suppressions.length > 0) lines.push(`Suppressions and lint-config changes this task added (QA judges each):\n${report.suppressions.slice(0, 10).map((entry) => `- ${entry}`).join("\n")}`);
+  return lines.join("\n");
+}
+
+/** The lint line under QA's verdict for the oracle: the summary, and whether it still holds completion. */
+export function lintBrief(report: LintReport | undefined, mode: LintMode, waived: boolean): string {
+  if (!report || mode === "off" || report.state === "skipped") return "";
+  const held = lintHolds(report, mode, waived) ? " Completion stays held until the new errors are fixed." : "";
+  return `Lint — ${lintSummary(report)}${held}`;
+}
+
+/** What QA reads: the engine's lint result, and every suppression it must judge. */
+export function lintContext(report: LintReport | undefined, mode: LintMode): string {
+  if (!report || mode === "off") return "";
+  const lines = [`Lint, run by the engine on the files this task touched (${mode} mode): ${lintSummary(report)}`];
+  const fresh = newFindings(report, 30);
+  if (fresh.length > 0) lines.push(`On lines this task changed:\n${fresh.map((finding) => findingLine(finding)).join("\n")}`);
+  const blocked = cannotRun(report);
+  if (blocked.length > 0) lines.push(`Could not run: ${blocked.join("; ")}. Read the touched files with the project's rules in mind instead.`);
+  lines.push(
+    report.suppressions.length > 0
+      ? `Suppressions and lint-config changes this task added. Judge each: one without a reason that holds (in a comment beside it, or the worker's report) is a finding, and so is a rule loosened or a file ignored to pass:\n${report.suppressions.map((entry) => `- ${entry}`).join("\n")}`
+      : "This task added no lint suppressions and changed no lint config. Still look for code removed or bent only to satisfy a rule.",
+  );
+  return lines.join("\n\n");
+}
+
+/** The activity log's line, and how it reads. */
+export function lintFeed(taskId: string, report: LintReport): { text: string; kind: "success" | "warning" | "error" | "info" } {
+  const first = newFindings(report, 1)[0];
+  const text = `${taskId} · ${lintSummary(report).replace(/\.$/, "")}${first ? ` — ${place(first)}${first.rule ? ` ${first.rule}` : ""}` : ""}`;
+  const kind = report.state === "failing" ? "error" : report.state === "unavailable" || report.freshWarnings > 0 || report.suppressions.length > 0 ? "warning" : report.state === "passing" ? "success" : "info";
+  return { text, kind };
+}
+
+/** Why completion is refused, for the oracle. */
+export function lintRefusal(report: LintReport): string {
+  const fresh = newFindings(report, 5).filter((finding) => finding.severity === "error");
+  return `lint found ${plural(report.freshErrors, "error")} on lines this task changed (${fresh.map((finding) => `${place(finding)}${finding.rule ? ` ${finding.rule}` : ""}`).join(", ")}${report.freshErrors > fresh.length ? ", …" : ""}). Delegate the fixes to the domain that touched each file and call complete again; the user can accept the work as it is with /bot-lobby accept`;
+}

package/src/workflow/track.ts

@@ -3,7 +3,8 @@
  * how much process it gets. A small, clear, low-risk request takes the fast
  * track: the oracle delegates straight to the agents it needs (no scouts, no
  * proposal round, no plan document), QA takes part only when the change
- * needs tests, and the researcher only when it needs facts from outside the
+ * needs tests (a fix to pin, a risky change, more than a small one; a small
+ * non-destructive change is left to the worker's checks and the lint gate), and the researcher only when it needs facts from outside the
  * repository. Anything bigger, riskier or unclear takes the full workflow.
  *
  * The engine reads the request once as the task starts, with the rules below
@@ -108,6 +109,9 @@ const RESEARCH = terms([
   "compatibility", "compatible with", "research", "verify online",
 ]);
 
+/** Wording that replaces or takes away existing behavior, rather than adding to it. */
+const DESTRUCTIVE = /\b(?:instead of|rather than|no longer|stop (?:returning|sending|accepting|allowing)|replac(?:e|es|ed|ing)|remov(?:e|es|ed|ing)|delet(?:e|es|ed|ing)|drop(?:s|ped|ping)?|renam(?:e|es|ed|ing)|deprecat(?:e|es|ed|ing)|break(?:s|ing)? (?:the )?(?:api|contract|format))\b/i;
+
 /** Serious whatever its size: security, money, data, production. Such a change gets a plan and the QA gate. */
 const RISK = terms([
   "security", "secure", "vulnerability", "vulnerabilities", "cve", "exploit", "xss", "csrf", "injection", "auth",
@@ -217,12 +221,17 @@ export function readRequest(request: string): RequestReading {
   if (backend) roster.add("backend");
   const asked = matched(TESTS, text) ?? (TEST_FILE.test(text) ? "a test file" : undefined);
   const bugfix = size !== "trivial" && !docsOnly ? matched(BUGFIX, text) : undefined;
+  const risk = matched(RISK, text);
+  const changes = backend && size !== "trivial" ? risk ?? matched(DESTRUCTIVE, text) : undefined;
+  // A small, additive change is covered by the worker's own checks and the lint gate; QA joins for what
+  // they cannot settle: a fix to pin, a backend change that is risky or replaces behavior, more than a
+  // small change, or tests asked for.
   const tests = asked
     ? `tests: asked for (${asked})`
     : bugfix
       ? `tests: a bug fix needs a regression test (${bugfix})`
-      : backend && size !== "trivial"
-        ? `tests: backend logic (${backend})`
+      : changes
+        ? `tests: a backend change that ${risk ? "touches" : "changes existing behavior:"} ${changes}`
         : size === "medium" || size === "large"
           ? "tests: the QA gate checks a change this size"
           : undefined;
@@ -236,7 +245,6 @@ export function readRequest(request: string): RequestReading {
     reasons.push(`research: ${research}`);
   }
 
-  const risk = matched(RISK, text);
   if (risk) reasons.push(`serious: touches ${risk}`);
   const vague = words < 8 && !concrete ? matched(VAGUE, text) : undefined;
   const undecided = matched(UNDECIDED, text);

package/src/workflow/workflow.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import type { BotLobbyConfig, ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, Pushback, ResearchResult, ReviewResult, WorkerResult } from "../schemas/findings.ts";
@@ -67,6 +67,9 @@ import { fastNext, onFastTrack, parseRoster, qaRequired, qaStillDue, qaTookPart,
 import { missingWorktree, taskCwd } from "../execution/workspace.ts";
 import { completionReview } from "../delivery/review.ts";
 import { execCommand, type Exec } from "../lobby/issues.ts";
+import type { LintExec } from "../execution/lint.ts";
+import type { LintReport } from "../schemas/lint.ts";
+import { lintBrief, lintContext, lintHolds, lintNote, lintRefusal, lintSummary, runLintGate } from "./lint.ts";
 
 export const ORCHESTRATE_ACTIONS = [
   "clarify",
@@ -159,6 +162,10 @@ export interface WorkflowDeps {
   triage?: (request: string, signal?: AbortSignal) => Promise<Task["triage"]>;
   /** Lowers thinking or the model for scouts and workers on steps the classifier judges simple or trivial. */
   effort?: EffortRouter;
+  /** Runs a linter for the lint gate (tests); the real one otherwise. */
+  lintExec?: LintExec;
+  /** Told each new lint report on a task's touched files (the lobby's activity log). */
+  onLint?: (taskId: string, report: LintReport) => void;
 }
 
 export interface WorkflowResult {
@@ -830,12 +837,43 @@ async function treeChanges(deps: WorkflowDeps, base?: string): Promise<{ top: st
   return { top: tree.top, files: tree.files.filter((file) => !file.startsWith(prefix)) };
 }
 
-/** Every changed file of the working tree, explained for this task; undefined without a baseline or git. */
-async function changeProvenance(deps: WorkflowDeps, task: Task, base?: string): Promise<FileProvenance[] | undefined> {
+/** Every changed file of the working tree, explained for this task, with the repository's top; undefined without a baseline or git. */
+async function changeState(deps: WorkflowDeps, task: Task, base?: string): Promise<{ top: string; files: FileProvenance[] } | undefined> {
   if (!task.baseline) return undefined;
   const tree = await treeChanges(deps, base);
   if (!tree) return undefined;
-  return explainChanges(task, tree.files, tree.top, readChanges(deps.root, deps.configDir, task.createdAt));
+  return { top: tree.top, files: explainChanges(task, tree.files, tree.top, readChanges(deps.root, deps.configDir, task.createdAt)) };
+}
+
+/** Who touched each file, as the oracle names them (`DEV`, `DESIGN/DEV`). */
+function ownersOf(files: readonly FileProvenance[] | undefined): Map<string, string> {
+  return new Map((files ?? []).filter((file) => file.domains?.length).map((file) => [file.path, file.domains!.map((domain) => AGENT_LABELS[domain]).join("/")]));
+}
+
+/**
+ * The lint gate (see lint.ts): lint the files this task's agents touched, as
+ * they stand, record the report on the task and tell the lobby when it is
+ * new. `tree` is the change state measured from the task's baseline, when the
+ * caller already has it. Nothing runs with lint off or before any worker.
+ */
+async function lintTask(task: Task, deps: WorkflowDeps, tree?: { top: string; files: FileProvenance[] }): Promise<LintReport | undefined> {
+  if (deps.config.lint.mode === "off" || !task.baseline) return undefined;
+  const state = tree ?? (await changeState(deps, task, task.baseline.head));
+  if (!state) return undefined;
+  const files = state.files.filter((file) => file.kinds.includes("planned") && existsSync(join(state.top, file.path))).map((file) => file.path);
+  const before = task.lint;
+  const report = await runLintGate({
+    top: state.top,
+    files,
+    ...(task.baseline.head ? { base: task.baseline.head } : {}),
+    config: deps.config.lint,
+    ...(before ? { previous: before } : {}),
+    ...(deps.lintExec ? { exec: deps.lintExec } : {}),
+    ...(deps.signal ? { signal: deps.signal } : {}),
+  });
+  task.lint = report;
+  if (report !== before && report.state !== "skipped") deps.onLint?.(task.id, report);
+  return report;
 }
 
 /** Who changed the tree, for the Master: counts, and what the changes that are not this task's mean for it. */
@@ -925,8 +963,9 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
     // A step that never reported (the call failed) does not stay "running" in the budget.
     for (const time of times.values()) settleAllotment(task, deps, time.id, "stopped");
   }
-  const note = provenanceNote(await changeProvenance(deps, task, task.baseline?.head));
-  return note ? `${report}\n\n${note}` : report;
+  const tree = await changeState(deps, task, task.baseline?.head);
+  const lint = lintNote(await lintTask(task, deps, tree), deps.config.lint.mode, ownersOf(tree?.files));
+  return [report, provenanceNote(tree?.files), lint].filter(Boolean).join("\n\n");
 }
 
 /**
@@ -1102,7 +1141,7 @@ const QA_INSTRUCTION = [
 ].join(" ");
 
 /** The QA gate looks at every domain's work, not just one worker's diff, knowing who changed each file. */
-function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: string, provenance?: readonly FileProvenance[]): ReviewerRequest {
+function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: string, provenance?: readonly FileProvenance[], lint?: LintReport): ReviewerRequest {
   const rounds = previousRound(task);
   return {
     taskId: task.id,
@@ -1113,6 +1152,7 @@ function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: s
     scoutOutcomes: loadScoutResults(taskReadDirs(deps.root, deps.configDir, task.id), [...new Set<Domain>(["qa", ...task.domains])]),
     diff,
     ...(provenance && provenance.length > 0 ? { provenance: provenanceLines(provenance) } : {}),
+    ...(lint ? { lint: lintContext(lint, deps.config.lint.mode) } : {}),
     instruction: instruction?.trim() || QA_INSTRUCTION,
     cwd: deps.cwd,
     dataRoots: readDataRoots(deps.root, deps.configDir),
@@ -1127,7 +1167,7 @@ function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: s
 /** What the loop does after a QA round: finish, fix and review again, stop, or (the user's call) accept the work as it is. */
 type LoopDecision = "accept" | "iterate" | "blocked" | "waived";
 
-function qaReport(outcome: ReviewerOutcome, decision: LoopDecision, provenance?: readonly FileProvenance[]): string {
+function qaReport(outcome: ReviewerOutcome, decision: LoopDecision, provenance?: readonly FileProvenance[], lint = ""): string {
   const { result, run, issues } = outcome;
   const passed = result.verdict === "pass";
   return [
@@ -1148,6 +1188,7 @@ function qaReport(outcome: ReviewerOutcome, decision: LoopDecision, provenance?:
     result.pushback ? pushbackLine(result.pushback, "qa") : "",
     issues.length > 0 ? `Issues: ${issues.join("; ")}` : "",
     provenanceNote(provenance),
+    lint,
   ]
     .filter((line) => line.length > 0)
     .join("\n");
@@ -1160,11 +1201,14 @@ async function handleQa(task: Task, params: OrchestrateParams, deps: WorkflowDep
   task.reviewIterations = { qa: iterations };
   const time = qaTime(task, deps);
   const base = await reviewBase(task, deps);
-  const [diff, provenance] = await Promise.all([
+  const [diff, tree] = await Promise.all([
     readRepositoryDiff(deps.cwd, { ...(base ? { base } : {}), exclude: ownRecords(deps) }),
-    changeProvenance(deps, task, base),
+    changeState(deps, task, base),
   ]);
-  const outcome = await runReviewer({ ...qaRequest(deps, task, diff, params.task, provenance), ...(time ? { time } : {}) }, deps.runProcess ?? spawnPiProcess);
+  const provenance = tree?.files;
+  // The gate's base is the task's own; a legacy task measured from an older commit lints from a fresh look.
+  const lint = await lintTask(task, deps, base === task.baseline?.head ? tree : undefined);
+  const outcome = await runReviewer({ ...qaRequest(deps, task, diff, params.task, provenance, lint), ...(time ? { time } : {}) }, deps.runProcess ?? spawnPiProcess);
   if (time) settleAllotment(task, deps, time.id, "finished");
   task.qaVerdict = outcome.result.verdict;
   recordReview(task, "qa", outcome.result);
@@ -1173,7 +1217,7 @@ async function handleQa(task: Task, params: OrchestrateParams, deps: WorkflowDep
   let decision: LoopDecision = decideReviewLoop(outcome.result.verdict, iterations, reviewLimit(task, deps));
   if (decision === "blocked") decision = await askAtReviewLimit(task, outcome.result, iterations, deps);
   if (decision === "accept") task.blockers = task.blockers.filter((blocker) => blocker.domain !== "qa");
-  return qaReport(outcome, decision, provenance);
+  return qaReport(outcome, decision, provenance, lintBrief(lint, deps.config.lint.mode, Boolean(task.lintWaiver)));
 }
 
 /** Review rounds allowed: the configured limit plus any the user granted. */
@@ -1228,6 +1272,8 @@ async function askAtReviewLimit(task: Task, result: ReviewResult, iterations: nu
  */
 export function waiveQa(task: Task, open: readonly string[], why: string): void {
   task.qaWaiver = { at: new Date().toISOString(), open: open.map((ask) => truncate(ask, 300)) };
+  // Accepting the work as it stands accepts its lint errors too.
+  if (task.lint?.state === "failing") waiveLint(task, why);
   const cleared = task.blockers.map((blocker) => blocker.reason);
   task.blockers = [];
   if (task.state === "blocked") transition(task, "implementing");
@@ -1235,6 +1281,13 @@ export function waiveQa(task: Task, open: readonly string[], why: string): void
   recordDecision(task, `The user accepted the work without a QA pass (${why}).${open.length > 0 ? ` QA still asked for: ${open.map((ask) => truncate(ask, 160)).join("; ")}.` : ""}${cleared.length > 0 ? ` Cleared blockers: ${cleared.join("; ")}.` : ""}`);
 }
 
+/** The user accepts the work with the lint errors it has: the lint gate no longer holds completion. */
+export function waiveLint(task: Task, why: string): void {
+  if (task.lintWaiver) return;
+  task.lintWaiver = { at: new Date().toISOString() };
+  recordDecision(task, `The user accepted the work with its lint errors (${why})${task.lint ? `: ${lintSummary(task.lint)}` : "."}`);
+}
+
 /** The last QA round's open asks, for a waiver made outside the loop. */
 export function lastQaAsks(task: Task): string[] {
   const last = task.reviewRecords.filter((record) => record.domain === "qa").at(-1);
@@ -1301,6 +1354,9 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   if (task.state === "blocked") throw new Error("cannot complete: the task is blocked, and the user did not accept its work as it is");
   const blockers = completionBlockers(task, pendingApprovals(task).length);
   if (blockers.length > 0) throw new Error(`cannot complete: ${blockers.join("; ")}`);
+  // New lint errors in what the task touched hold it in block mode, unless the user accepted the work as it is.
+  const lint = await lintTask(task, deps);
+  if (lint && lintHolds(lint, deps.config.lint.mode, Boolean(task.lintWaiver))) throw new Error(`cannot complete: ${lintRefusal(lint)}`);
   // The gate refuses before any side effect, so a refusal leaves the task untouched.
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
@@ -1313,7 +1369,8 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   task.delivery = await completionReview(task, deps.root, { cwd: deps.root, exec: deps.exec ?? execCommand });
   deps.notify(`Task ${task.id} is completed. Delivery review is available; publishing requires your approval.`, "info");
   flushDecisions(deps, task);
-  return `Task ${task.id} completed. History recorded and temporary scratchpads removed. Delivery review is available; nothing was published.`;
+  const left = lint?.state === "failing" ? ` ${task.lintWaiver ? "Accepted by the user with lint errors" : "Lint (advisory)"}: ${lintSummary(lint)} Tell the user.` : "";
+  return `Task ${task.id} completed. History recorded and temporary scratchpads removed. Delivery review is available; nothing was published.${left}`;
 }
 
 /** Asked when the oracle completes a task QA has not passed (the user told it to finish, say). */