@a-t-h-i/bot-lobby 0.6.45 → 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.45",
+  "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/execution/task-cancellation.ts

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+
+const executions = new Map<string, Set<AbortController>>();
+const key = (root: string, configDir: string, taskId: string) => JSON.stringify([resolve(root), configDir, taskId]);
+
+/** Scope an orchestration action and its workers/children to one project task. */
+export function taskExecution(root: string, configDir: string, taskId: string, parent?: AbortSignal) {
+  const id = key(root, configDir, taskId);
+  const controller = new AbortController();
+  const running = executions.get(id) ?? new Set<AbortController>();
+  running.add(controller);
+  executions.set(id, running);
+  return {
+    signal: parent ? AbortSignal.any([parent, controller.signal]) : controller.signal,
+    release: () => {
+      running.delete(controller);
+      if (!running.size) executions.delete(id);
+    },
+  };
+}
+
+/** Abort only this task's orchestration and the subprocesses inheriting its signal. */
+export function cancelTaskExecutions(root: string, configDir: string, taskId: string): void {
+  for (const controller of executions.get(key(root, configDir, taskId)) ?? []) {
+    controller.abort(new Error("Task abandoned by the user"));
+  }
+}

package/src/lobby/host.ts

@@ -173,6 +173,10 @@ export interface LobbyService {
    * background session. A notice, and the background session's key.
    */
   resumeTask?(taskId: string): Promise<{ notice: string; key?: string }>;
+  acceptTask?(taskId: string): Promise<{ notice: string }>;
+  forceCloseTask?(taskId: string, title: string): Promise<{ notice: string }>;
+  canForceCloseTask?(taskId: string): boolean;
+  resolveTaskApproval?(taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }>;
   /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
   sendToSession(sessionId: string, text: string): string;
   /** Sessions running in this project, other than this window's, from their heartbeats. */

package/src/lobby/prompts.ts

@@ -4,7 +4,7 @@
  * `node:*`): the web page imports this file directly.
  */
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge", "metrics"] as const;
+export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "git", "knowledge"] as const;
 export type TabId = (typeof TAB_IDS)[number];
 
 export const TAB_LABELS: Record<TabId, string> = {
@@ -12,7 +12,6 @@ export const TAB_LABELS: Record<TabId, string> = {
   tasks: "Tasks",
   plan: "Plan",
   quickfix: "Quick fix",
-  metrics: "Metrics",
   git: "Git",
   knowledge: "Knowledge",
 };

package/src/lobby/service.ts

@@ -9,6 +9,8 @@ import { updateBlockingRequest } from "../state/blocking-requests.ts";
 import { randomUUID } from "node:crypto";
 import { loadTask, ownedTask, peekOwnedTask, peekTasks, saveTask } from "../state/persistence.ts";
 import { taskWork } from "../state/work-time.ts";
+import { transition } from "../state/task-state.ts";
+import { cancelTaskExecutions } from "../execution/task-cancellation.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest } from "../delivery/operations.ts";
 import { deliveryStore, deliveryTask } from "../delivery/store.ts";
@@ -18,7 +20,7 @@ import { loadConfig, readDataRoots, saveConfig as writeConfig } from "../state/p
 import { knowledgeQuestion } from "./knowledge.ts";
 import { addPlanComment, editComment, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
-import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
+import { markInboxDelivered, sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
 import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
@@ -50,6 +52,9 @@ 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";
+import { handleResolveApproval, lastQaAsks, waiveLint, waiveQa } from "../workflow/workflow.ts";
+import { recordDecision } from "../master/decisions.ts";
+import { fail } from "../webui/api/index.ts";
 
 /** The state background callbacks report to; set while the lobby service runs. */
 let serviceState: Runtime | undefined;
@@ -384,6 +389,73 @@ async function resumeTask(state: Runtime, taskId: string): Promise<{ notice: str
   }
 }
 
+function mutableTask(state: Runtime, taskId: string): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (TERMINAL_STATES.includes(task.state)) fail(400, "bad_request", "task is terminal");
+  return task;
+}
+
+async function wakeTask(state: Runtime, task: Task, message: string): Promise<string> {
+  const inbox = sendToInbox(state.root, state.configDir, task.id, message, state.ctx.sessionManager.getSessionId());
+  const route = resumeRoute(task, taskDrivers(state));
+  if (route.kind === "stopped" || route.kind === "paused") return (await resumeTask(state, task.id)).notice;
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) {
+    state.pi.sendUserMessage(message, state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+    markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+  } else {
+    const session = backgroundSessions().find((entry) => entry.alive && entry.projectRoot === state.root && entry.sessionId === task.ownerSessionId);
+    if (session) {
+      session.send(message);
+      markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
+    }
+  }
+  return "the owning oracle has been notified";
+}
+
+function canForceCloseTask(state: Runtime, taskId: string): boolean {
+  const task = loadTask(state.root, state.configDir, taskId);
+  return Boolean(task && !TERMINAL_STATES.includes(task.state) && (!task.ownerSessionId || task.ownerSessionId === state.ctx.sessionManager.getSessionId()));
+}
+
+async function forceCloseTask(state: Runtime, taskId: string, title: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (title !== task.title) fail(400, "bad_request", "the title must match exactly");
+  if (!canForceCloseTask(state, taskId)) fail(400, "bad_request", "cancel this task in its owning session; remote cancellation is unavailable");
+  recordDecision(task, "The user force-closed the task from the Tasks screen; work abandoned, code and worktree retained.");
+  transition(task, "abandoned");
+  saveTask(state.root, state.configDir, task);
+  cancelTaskExecutions(state.root, state.configDir, task.id);
+  if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) state.ctx.abort();
+  lobbyTopics.bump("tasks");
+  return { notice: `${task.id} abandoned; code, worktree and history retained` };
+}
+
+async function acceptTask(state: Runtime, taskId: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!["implementing", "reviewing", "blocked"].includes(task.state)) fail(400, "bad_request", "there is no work to accept yet");
+  const asks = lastQaAsks(task);
+  if (task.qaVerdict !== "pass" && !task.qaWaiver) waiveQa(task, asks, "from the Tasks screen");
+  if (task.lint?.state === "failing") waiveLint(task, "from the Tasks screen");
+  recordDecision(task, "The user accepted the work as it is from the Tasks screen; the oracle was asked to complete it.");
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  const wake = await wakeTask(state, task, `The user accepted ${task.id}'s work as it is. Call orchestrate action=complete now with a short summary naming outstanding QA/lint asks: ${asks.join("; ") || "none recorded"}. Read the persisted gate waivers first. Do not merge automatically.`);
+  return { notice: `${task.id} accepted as it is; ${wake}` };
+}
+
+async function resolveTaskApproval(state: Runtime, taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  if (!task.approvals.some((entry) => entry.id === approvalId && entry.status === "pending")) fail(409, "conflict", "approval is no longer pending");
+  let message: string;
+  try { message = handleResolveApproval(task, { action: "resolve_approval", approvalId, decision, note }); }
+  catch (error) { return fail(400, "bad_request", (error as Error).message); }
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  return { notice: `${message}; ${await wakeTask(state, task, message)}` };
+}
+
 /** Leave a message for a task another terminal's session drives; its owner passes it to the oracle. */
 function sendToTask(state: Runtime, taskId: string, text: string): string {
   const task = loadTask(state.root, state.configDir, taskId);
@@ -826,6 +898,10 @@ export function createLobbyService(state: Runtime): LobbyService {
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
     resumeTask: (taskId) => resumeTask(state, taskId),
+    acceptTask: (taskId) => acceptTask(state, taskId),
+    forceCloseTask: (taskId, title) => forceCloseTask(state, taskId, title),
+    canForceCloseTask: (taskId) => canForceCloseTask(state, taskId),
+    resolveTaskApproval: (taskId, approvalId, decision, note) => resolveTaskApproval(state, taskId, approvalId, decision, note),
     sendToSession: (sessionId, text) => sendToSession(state, sessionId, text),
     liveSessions: () => liveSessions(state),
     switchTo: (target) => switchTo(state, target),

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/state/persistence.ts

@@ -89,13 +89,38 @@ export function readTaskArtifact(
 
 export function saveTask(root: string, configDir: string, task: Task): void {
   const latest = loadTask(root, configDir, task.id);
-  if (latest) mergePhaseTiming(task, timingBaselines.get(task), latest);
+  // Abandonment is final: an in-flight action must not overwrite its audit or resurrect it.
+  if (latest?.state === "abandoned") {
+    Object.assign(task, latest);
+    return;
+  }
+  if (latest) {
+    preserveUserInterventions(task, latest);
+    mergePhaseTiming(task, timingBaselines.get(task), latest);
+  }
   const path = join(taskDir(dataRoot(root, configDir), task.id), "state.json");
   forgetCached(path);
   writeFileEnsured(path, JSON.stringify(task, null, 2));
   rememberTiming(task);
 }
 
+/** Explicit user waivers and resolved approvals must survive an in-flight worker's snapshot. */
+function preserveUserInterventions(task: Task, latest: Task): void {
+  const newlyWaived = !task.qaWaiver && latest.qaWaiver;
+  task.qaWaiver ??= latest.qaWaiver;
+  task.lintWaiver ??= latest.lintWaiver;
+  if (newlyWaived && !TERMINAL_STATES.includes(task.state)) {
+    task.blockers = [];
+    if (["implementing", "blocked"].includes(task.state)) task.state = "reviewing";
+  }
+  for (const approval of task.approvals) {
+    const resolved = latest.approvals.find((entry) => entry.id === approval.id && entry.status !== "pending");
+    if (approval.status === "pending" && resolved) Object.assign(approval, resolved);
+  }
+  const keys = new Set(task.decisions.map((entry) => JSON.stringify(entry)));
+  task.decisions.push(...latest.decisions.filter((entry) => !keys.has(JSON.stringify(entry))));
+}
+
 /** Read a task state: the bot-lobby copy wins, else the newest pre-rename copy. */
 export function loadTask(root: string, configDir: string, taskId: string): Task | undefined {
   for (const dr of readDataRoots(root, configDir)) {

package/src/webui/api/index.ts

@@ -15,8 +15,7 @@ import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
 import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave, plannerPrevious, plannerPreviousArchive, plannerPreviousDelete, plannerPreviousGet, plannerPreviousOpen } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver } from "./tasks.ts";
-import { metricsGet } from "./metrics.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver, tasksAccept, tasksForceClose, tasksResolveApproval } from "./tasks.ts";
 import { knowledgeAdd, knowledgeAsk, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
@@ -131,6 +130,18 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksResume(body as { taskId: string }, ctx),
   };
+  routes["tasks.accept"] = {
+    schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
+    run: (body, ctx) => tasksAccept(body as { taskId: string }, ctx),
+  };
+  routes["tasks.forceClose"] = {
+    schema: Type.Object({ taskId: TaskId, title: Type.String({ maxLength: 20_000 }) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksForceClose(body as { taskId: string; title: string }, ctx),
+  };
+  routes["tasks.resolveApproval"] = {
+    schema: Type.Object({ taskId: TaskId, approvalId: TaskId, decision: Type.Union([Type.Literal("approved"), Type.Literal("rejected")]), note: Type.Optional(NoticeText) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksResolveApproval(body as Parameters<typeof tasksResolveApproval>[0], ctx),
+  };
   routes["tasks.deliveryReview"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksDeliveryReview(body as { taskId: string }, ctx),
@@ -268,10 +279,6 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ id: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => quickfixMovedToTask(body as { id: string }, ctx),
   };
-  routes["metrics.get"] = {
-    schema: Type.Object({ groupBy: Type.Union([Type.Literal("model"), Type.Literal("model-kind")]), query: Type.Optional(Type.String({ maxLength: 500 })), from: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), to: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), timeZone: Type.Optional(Type.String({ maxLength: 100 })) }, { additionalProperties: false }),
-    run: (body, ctx) => metricsGet(body as Parameters<typeof metricsGet>[0], ctx),
-  };
   routes["knowledge.files"] = { schema: Empty, run: (_body, ctx) => knowledgeFiles(ctx) };
   routes["knowledge.ask"] = {
     schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),

package/src/webui/api/tasks.ts

@@ -282,17 +282,52 @@ export function tasksOpen(body: { taskId: string }, ctx: ApiContext): { sessionI
   return { notice: "The task's owning session has ended or is unavailable. No replacement session was created." };
 }
 
+/** Interventions only apply to an active task in this project, never an archive. */
+function interventionTask(taskId: string, ctx: ApiContext): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = ctx.service.tasks().find((entry) => entry.id === taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (TERMINAL_STATES.includes(task.state)) fail(400, "bad_request", "this task is already finished");
+  return task;
+}
+
+function acceptable(task: Task): boolean {
+  return ["implementing", "reviewing", "blocked"].includes(task.state);
+}
+
+export async function tasksAccept(body: { taskId: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (!acceptable(task)) fail(400, "bad_request", "only implementing, reviewing or blocked tasks can be accepted");
+  if (!ctx.service.acceptTask) fail(400, "bad_request", "accepting tasks is unavailable");
+  return ctx.service.acceptTask(body.taskId);
+}
+
+export async function tasksForceClose(body: { taskId: string; title: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (body.title !== task.title) fail(400, "bad_request", "the title must match exactly");
+  if (!ctx.service.forceCloseTask) fail(400, "bad_request", "force closing tasks is unavailable");
+  return ctx.service.forceCloseTask(body.taskId, body.title);
+}
+
+export async function tasksResolveApproval(body: { taskId: string; approvalId: string; decision: "approved" | "rejected"; note?: string }, ctx: ApiContext): Promise<{ notice: string }> {
+  const task = interventionTask(body.taskId, ctx);
+  if (!pendingApprovals(task).some((approval) => approval.id === body.approvalId)) fail(409, "conflict", "approval is no longer pending; refresh the task");
+  if (!ctx.service.resolveTaskApproval) fail(400, "bad_request", "resolving task approvals is unavailable");
+  return ctx.service.resolveTaskApproval(body.taskId, body.approvalId, body.decision, body.note);
+}
+
 /** How many recent runs the detail lists (the terminal's count). */
 const DETAIL_RUNS = 6;
 
 /** The terminal's "Waiting on" approvals: `kind` plus `for <domain>: <detail>`. */
 function waitingOf(task: Task): TaskDetail["waiting"] {
-  return pendingApprovals(task).map((approval) => ({ kind: approval.kind, detail: `for ${approval.domain}: ${approval.detail}` }));
+  return pendingApprovals(task).map((approval) => ({ id: approval.id, domain: approval.domain, kind: approval.kind, detail: `for ${approval.domain}: ${approval.detail}` }));
 }
 
 /** One task read whole: request, plan or proposal, step checklist, waits and recent runs. */
 export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail {
-  const task = [...ctx.service.tasks(), ...ctx.service.archivedTasks()].find((entry) => entry.id === body.taskId);
+  const active = ctx.service.tasks().find((entry) => entry.id === body.taskId);
+  const task = active ?? ctx.service.archivedTasks().find((entry) => entry.id === body.taskId);
   if (!task) fail(404, "not_found", `no task ${body.taskId}`);
   const found = task as Task;
   const request = taskRequest(found);
@@ -301,6 +336,8 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
   const clock = clockOf(found, work);
   const details = found.plan ? planDetails(found.plan) : undefined;
   return {
+    canAccept: Boolean(active && ctx.service.acceptTask) && acceptable(found),
+    canForceClose: Boolean(active && ctx.service.forceCloseTask) && !TERMINAL_STATES.includes(found.state) && (ctx.service.canForceCloseTask?.(found.id) ?? true),
     timing: projectPhaseTiming(found, new Date(now).toISOString()),
     ...(clock ? { work: clock } : {}),
     ...(found.delivery ? { delivery: found.delivery } : {}),