@a-t-h-i/bot-lobby 0.6.46 → 0.6.47

package/THIRD_PARTY_NOTICES.md

@@ -60,3 +60,13 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
+
+## Typefaces
+
+The web UI bundles the Latin subset of these variable fonts (from the
+fontsource packages, `@fontsource-variable/*`) as files in `webui/dist/assets`,
+so the Typeface setting works offline. Each is under the SIL Open Font
+License 1.1 (https://openfontlicense.org): Inter (The Inter Project Authors),
+Geist and Geist Mono (Vercel), IBM Plex Sans (IBM Corp.), Manrope (The
+Manrope Project Authors) and JetBrains Mono (The JetBrains Mono Project
+Authors).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.46",
+  "version": "0.6.47",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -57,6 +57,12 @@
     "@earendil-works/pi-ai": "1.0.1",
     "@earendil-works/pi-coding-agent": "1.0.1",
     "@earendil-works/pi-tui": "1.0.1",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
+    "@fontsource-variable/ibm-plex-sans": "^5.3.0",
+    "@fontsource-variable/inter": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0",
+    "@fontsource-variable/manrope": "^5.3.0",
     "@playwright/test": "1.62.0",
     "@tailwindcss/vite": "4.3.3",
     "@types/node": "^22.10.0",

package/prompts/qa.md

@@ -55,7 +55,7 @@ you state in the report.
 6. Run the smallest useful set of them.
 7. Decide what confidence is still missing.
 8. Only for a meaningful uncovered risk, add a behavioural test.
-9. PASS or FAIL.
+9. Give the verdict: PASS, CHANGES_REQUIRED or BLOCKED.
 
 Never duplicate coverage that exists, and never rewrite existing tests because
 you prefer another style.
@@ -101,6 +101,12 @@ re-running it. Use the project's own type checker, build and existing tests
 before judging by reading, and run the narrowest command that answers the
 question (one test file, one test name, the touched package's typecheck).
 Run a whole suite only at HIGH risk, or when the change touches shared logic.
+A failure is the task's only when the change causes it. A test that fails in
+code the diff does not touch, for a reason the diff cannot explain, was
+already failing: list it as an `info` finding and judge the change on the rest.
+When you cannot tell, run that one test at the task's base commit in a
+throwaway worktree (`git worktree add <tmp dir> <base>`; remove it after) —
+never stash, reset or check out over the working tree.
 Do not re-run a check the worker already ran on the same files with the same
 result; cite it. Always pass a bash `timeout`, and never start watch mode or
 long-running servers.
@@ -147,9 +153,11 @@ A PASS is a claim backed by evidence, not an absence of complaints.
   A PASS without executed checks is downgraded by the engine to
   CHANGES_REQUIRED.
 - Check every acceptance criterion; an unmet or unverifiable one is a finding.
-- If you could not verify something important (no test runner, a failing
-  environment, missing access), say so and return CHANGES_REQUIRED or BLOCKED —
-  never PASS on assumption.
+- If you could not verify something important, say so and never PASS on
+  assumption. Verify it another way first (the typecheck, a narrower test,
+  reading the code path); if it stays unverifiable, return CHANGES_REQUIRED
+  with what is missing. BLOCKED is only for a review that cannot happen at
+  all, and it stops the task until the user steps in.
 
 ## Testing conventions
 

package/prompts/reviewer.md

@@ -108,7 +108,13 @@ If implementation changes are required, report them to the Master.
   behaviour, a failing check, an unmet acceptance criterion, a security
   problem. Tag every finding with its severity.
 - **BLOCKED** only when you cannot review at all (it does not build, the
-  checks cannot run).
+  checks cannot run). It stops the task until the user steps in, so never use
+  it for something the workers can fix.
+- **Pre-existing failures are not the task's.** A check that fails in code
+  the diff does not touch, for a reason the diff cannot explain, was already
+  failing: note it as an `info` finding and judge the change on the rest. When
+  unsure, run that check at the task's base commit in a throwaway worktree
+  (`git worktree add`), never by stashing or resetting the working tree.
 - **A re-review verifies; it does not start over.** When your context lists
   what the previous round asked for, check each item first and say which are
   addressed. Do not raise the bar between rounds: a new blocking finding must

package/src/master/master.ts

@@ -12,7 +12,7 @@ import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.
 import { scriptsFor } from "../scripts/pick.ts";
 import { summarizeOutcomes } from "./synthesis.ts";
 import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
-import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
+import { parseReviewResult, readVerdict, validateReviewResult } from "../roles/reviewer.ts";
 import { truncate } from "../text.ts";
 import { isScoutResultUsable, parseScoutResult, validateScoutResult } from "../roles/scout.ts";
 import { treeState } from "../execution/git.ts";
@@ -433,9 +433,9 @@ function reviewerContext(request: ReviewerRequest): string {
     .join("\n\n");
 }
 
-/** True when the output carries the reviewer contract's required heading. */
+/** True when a verdict can be read from the output (the contract's heading, or a line naming it). */
 export function hasReviewVerdict(text: string): boolean {
-  return /##\s*verdict/i.test(text);
+  return readVerdict(text) !== undefined;
 }
 
 /** A success without the Verdict section is off-contract and worth resampling. */

package/src/roles/reviewer.ts

@@ -23,11 +23,34 @@ export const reviewerSpec: RoleSpec = {
 
 const SEVERITIES: readonly Severity[] = ["critical", "major", "minor", "info"];
 
-function parseVerdict(text: string | undefined): Verdict {
-  const value = (text ?? "").toUpperCase();
-  if (value.includes("CHANGES REQUIRED") || value.includes("CHANGES_REQUIRED")) return "changes_required";
-  if (value.includes("PASS")) return "pass";
-  return "blocked";
+/** Severity words reviewers use outside the contract's four, mapped onto them. */
+const SEVERITY_ALIASES: ReadonlyArray<[RegExp, Severity]> = [
+  [/\b(?:blocker|blocking|severe)\b/, "critical"],
+  [/\bhigh\b/, "major"],
+  [/\b(?:low|nit|nitpick|trivial|cosmetic|optional|suggestion)\b/, "minor"],
+  [/\b(?:note|fyi)\b/, "info"],
+];
+
+/**
+ * Verdict words in the order a reviewer writes them. FAIL is the word qa.md
+ * used to ask for: it means changes are required, not that QA could not run.
+ */
+const VERDICT_TOKENS: ReadonlyArray<[RegExp, Verdict]> = [
+  [/\bCHANGES?[\s_-]*(?:REQUIRED|REQUESTED|NEEDED)\b|\b(?:NEEDS|REQUEST(?:ED)?)[\s_-]+CHANGES\b/, "changes_required"],
+  [/\bFAIL(?:ED|S|URE)?\b/, "changes_required"],
+  [/\bBLOCKED\b/, "blocked"],
+  [/\bPASS(?:ED|ES)?\b/, "pass"],
+];
+
+/** The first verdict word in the text, so `PASS — no changes required` reads as the PASS it leads with. */
+function verdictToken(text: string): Verdict | undefined {
+  const value = text.toUpperCase();
+  let best: { at: number; verdict: Verdict } | undefined;
+  for (const [pattern, verdict] of VERDICT_TOKENS) {
+    const match = pattern.exec(value);
+    if (match && (!best || match.index < best.at)) best = { at: match.index, verdict };
+  }
+  return best?.verdict;
 }
 
 /** The verdict token may sit in the heading itself (`## Verdict PASS`), leaving an empty body. */
@@ -38,14 +61,35 @@ function verdictHeading(sections: Map<string, string>): string | undefined {
   return undefined;
 }
 
+/**
+ * The reviewer's verdict, or undefined when none can be read. The contract's
+ * `## Verdict` section comes first; failing that, a line that names the
+ * verdict (`**Verdict:** PASS`, `# Verdict: PASS`) and the line after it.
+ */
+export function readVerdict(raw: string, sections = parseSections(raw)): Verdict | undefined {
+  const heading = verdictHeading(sections);
+  if (heading !== undefined) {
+    const body = (findSection(sections, "verdict") ?? "").split("\n").filter((line) => line.trim()).slice(0, 2).join("\n");
+    const found = verdictToken(`${heading}\n${body}`);
+    if (found) return found;
+  }
+  const lines = raw.split("\n");
+  const at = lines.findIndex((line) => /\bverdict\b/i.test(line));
+  if (at < 0) return undefined;
+  const next = lines.slice(at + 1).find((line) => line.trim()) ?? "";
+  return verdictToken(`${lines[at]}\n${next}`);
+}
+
 /** The severity a finding was tagged with, or undefined when it carries none. */
 function taggedSeverity(text: string): Severity | undefined {
-  const match = /^\[([^\]]+)\]/.exec(text);
-  return SEVERITIES.find((candidate) => match?.[1]?.toLowerCase().includes(candidate));
+  const tag = /^\*{0,2}\[([^\]]+)\]/.exec(text)?.[1]?.toLowerCase();
+  if (!tag) return undefined;
+  return SEVERITIES.find((candidate) => tag.includes(candidate))
+    ?? SEVERITY_ALIASES.find(([pattern]) => pattern.test(tag))?.[1];
 }
 
 function parseFinding(text: string): ReviewFinding {
-  const match = /^\[([^\]]+)\]\s*(.*)$/.exec(text);
+  const match = /^\*{0,2}\[([^\]]+)\]\*{0,2}\s*(.*)$/.exec(text);
   return { severity: taggedSeverity(text) ?? "info", text: (match?.[2] ?? text).trim() };
 }
 
@@ -55,9 +99,38 @@ export const UNVERIFIED_PASS = "unverified pass: PASS without executed checks un
 /** Minor and info findings never hold the gate; what the reviewer asked for is kept as follow-ups. */
 export const MINOR_ONLY = "CHANGES_REQUIRED for minor or info findings only: passed, its asks kept as follow-ups";
 
-/** A verification bullet names a command or check and its result (`- cmd — result`). */
+/** No verdict could be read: the review did not finish, so it is run again rather than stopping the task. */
+export const NO_VERDICT = "no readable verdict: the review did not finish, so nothing is known yet about the work";
+
+/** A check names a command and its result: `cmd — result`, `cmd: result`, `✅ cmd`, `cmd (40/40)` or `cmd passed`. */
+const CHECK_RESULT = /\S\s*(?:—|–|-{1,2}|:|=>|→|->)\s*\S|[✅✓✔❌✗✘]|\(\s*\d+\s*\/\s*\d+\s*\)|\b(?:pass(?:ed|es|ing)?|fail(?:ed|s|ing)?|clean|exit(?:ed)?\s*(?:code\s*)?\d+|\d+\s+(?:tests?|passing|passed|failing|failed))\b/i;
+
+/** A table row's cells, or undefined for a line that is not a row. */
+function tableCells(line: string): string[] | undefined {
+  if (!/^\|.*\|$/.test(line)) return undefined;
+  return line.slice(1, -1).split("|").map((cell) => cell.trim());
+}
+
+/**
+ * The checks under `## Verification`: bullets, numbered items and table rows
+ * that name a command and its result. A reviewer's list style never decides
+ * whether the gate believes it ran something.
+ */
 function executedChecks(verification: string): string[] {
-  return bullets(verification).filter((entry) => /\S\s*(?:—|–|-{1,2}|:|=>|→)\s*\S/.test(entry));
+  const lines = verification.split("\n").map((line) => line.trim());
+  const checks: string[] = [];
+  lines.forEach((line, index) => {
+    const cells = tableCells(line);
+    if (cells) {
+      const separator = cells.every((cell) => /^:?-{2,}:?$/.test(cell));
+      const header = tableCells(lines[index + 1] ?? "")?.every((cell) => /^:?-{2,}:?$/.test(cell));
+      if (!separator && !header && cells.filter(Boolean).length >= 2) checks.push(cells.join(" — "));
+      return;
+    }
+    const item = /^(?:[-*+]|\d+[.)])\s+(\S.*)$/.exec(line)?.[1];
+    if (item && CHECK_RESULT.test(item)) checks.push(item);
+  });
+  return checks;
 }
 
 /** Parse a reviewer's markdown into a structured verdict (never throws). */
@@ -66,11 +139,15 @@ export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
   const verification = findSection(sections, "verification") ?? "";
   const requiredChanges = bullets(findSection(sections, "required changes"));
   const entries = bullets(findSection(sections, "findings"));
-  let verdict = parseVerdict(`${verdictHeading(sections) ?? ""}\n${findSection(sections, "verdict") ?? ""}`);
+  const read = readVerdict(raw, sections);
+  let verdict: Verdict = read ?? "changes_required";
   let downgraded: string | undefined;
   let relaxed: string | undefined;
   const checked = executedChecks(verification).length > 0;
-  if (verdict === "pass" && !checked) {
+  if (!read) {
+    // Never a pass, and never a stop either: an unreadable review is run again.
+    requiredChanges.push("Re-run the QA gate: the last review returned no readable verdict.");
+  } else if (verdict === "pass" && !checked) {
     verdict = "changes_required";
     downgraded = UNVERIFIED_PASS;
     requiredChanges.push("Re-run the QA gate and record the checks actually executed, each as `- command — result`.");
@@ -93,6 +170,7 @@ export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
     pushback: parsePushback(sections),
     ...(downgraded ? { downgraded } : {}),
     ...(relaxed ? { relaxed } : {}),
+    ...(read ? {} : { unread: NO_VERDICT }),
     raw,
   };
 }
@@ -100,7 +178,7 @@ export function parseReviewResult(domain: Domain, raw: string): ReviewResult {
 /** An unknown verdict must never be treated as acceptance (§42). */
 export function validateReviewResult(result: ReviewResult): string[] {
   const issues: string[] = [];
-  if (!/##\s*verdict/i.test(result.raw)) issues.push("missing Verdict section");
+  if (result.unread) issues.push("missing Verdict section");
   if (result.downgraded) issues.push(result.downgraded);
   if (result.verdict !== "pass" && result.findings.length === 0 && result.requiredChanges.length === 0) {
     issues.push("non-pass verdict without findings or required changes");

package/src/schemas/findings.ts

@@ -89,6 +89,8 @@ export interface ReviewResult {
   downgraded?: string;
   /** Set when the engine passed a CHANGES_REQUIRED that named only minor or info findings. */
   relaxed?: string;
+  /** Set when no verdict could be read from the review (a failed or off-contract run). */
+  unread?: string;
   raw: string;
 }
 

package/src/workflow/workflow.ts

@@ -1289,7 +1289,9 @@ function qaReport(header: string, result: ReviewResult, decision: LoopDecision,
       : decision === "waived"
         ? "The user accepted the work as it is, without a QA pass. Call action=complete now with a short summary that names what QA still asked for."
         : decision === "iterate"
-          ? "The QA gate did not pass: delegate the required changes to the owning domain, then re-run action=qa."
+          ? result.unread
+            ? "QA returned no readable verdict, so nothing is known about the work yet: re-run action=qa; there is nothing to fix first."
+            : "The QA gate did not pass: delegate the required changes to the owning domain, then re-run action=qa."
           : "The review limit is reached and the user did not accept the work: mark the task blocked and tell the user what QA still asks for. They can accept it with /bot-lobby accept.",
     result.pushback ? pushbackLine(result.pushback, "qa") : "",
     issues.length > 0 ? `Issues: ${issues.join("; ")}` : "",