pi-claude-supervisor 0.9.1 → 0.9.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented here.
 
+## [0.9.2](https://github.com/btnalit/pi-claude-supervisor/compare/v0.9.1...v0.9.2) (2026-09-24)
+
+
+### Bug Fixes
+
+* **supervisor:** finish stop and startup races; add gated live Decision spike ([#67](https://github.com/btnalit/pi-claude-supervisor/issues/67)) ([648b269](https://github.com/btnalit/pi-claude-supervisor/commit/648b269f185fbeb5ab39fe22ce855cc8d4342747))
+* **supervisor:** stability fixes found by end-to-end runs with a real Decision Worker ([#65](https://github.com/btnalit/pi-claude-supervisor/issues/65)) ([cd0b8ef](https://github.com/btnalit/pi-claude-supervisor/commit/cd0b8efdd0898833036b14acab5ca7b29ca70d04))
+
 ## [0.9.1](https://github.com/btnalit/pi-claude-supervisor/compare/v0.9.0...v0.9.1) (2026-09-24)
 
 

package/docs/architecture.md

@@ -517,10 +517,17 @@ parked or failed without granting remote/main authority. Model/API failures are
 detected from the Pi `stopReason` (a provider error resolves the prompt normally
 rather than throwing); if the Decision Worker
 API/model call fails, the system records `decision_worker_failed`, applies the
-bounded retry/park policy and preserves the candidate evidence. An abort is never
+bounded retry/park policy and preserves the candidate evidence. The startup
+instructions prompt retries provider errors on the same backoff and budget, so a
+provider overload at start does not fail the task before its first turn. An abort is never
 retried, and a `noop` reply on a completed turn or a permission request parks the
 candidate rather than being treated as a resolved decision, while a `noop` on a
-clean Worker exit proceeds to verification. Optional alert
+clean Worker exit proceeds to verification. A `stop` on a completed turn of an
+unattended task without remote authority stops the Worker (never keeping it open)
+and then verifies its finished work instead of discarding it (`decision_overridden`);
+no repair round may follow, so a failure blocks the candidate. A `stop` on a
+pending permission, on a turn the Worker has already resumed, or on a task with
+remote authority stays a plain stop. Optional alert
 delivery remains independent from event-log persistence, but notification is not
 the control boundary.
 
@@ -617,6 +624,10 @@ evidence still parks.
 
 A `revise` result produces an audited repair round and sends a bounded corrective
 instruction to a still-live `repairableSession` Worker. Checks and review then run again.
+The Decision Worker sees the last result tagged with the Worker turn it judged, and chooses
+when to verify again; if it keeps steering instead, the Supervisor verifies on its own once
+the Worker has taken three turns since that failure (`decision_overridden`), so a Decision
+Worker reasoning from the stale failure cannot hold a fixed Worker in a loop until the deadline.
 The repair budget defaults to three rounds. P0/P1 findings block a `pass` but are repair
 inputs like any other concrete finding (a `pass` carrying one is treated as `revise`); a
 `human` verdict, repeated findings or an exhausted budget stop automation and park a

package/docs/testing.md

@@ -113,6 +113,43 @@ PI_CLAUDE_SUPERVISOR_REAL_CLAUDE_PATH="$HOME/.local/share/mise/installs/claude/l
 PI_CLAUDE_SUPERVISOR_REAL_CLAUDE=1 npm run spike:tmux
 ```
 
+The Decision spike runs a real Pi Decision Worker and Reviewer, on any Pi
+model, against a scripted Worker that edits a temporary git repository. It
+needs no Claude Code, cgroup or tmux, so it runs on hosts that cannot run the
+real-Claude spikes. It is gated and excluded from normal CI:
+
+```bash
+# Default model: google/gemini-3.5-flash-lite
+PI_CLAUDE_SUPERVISOR_REAL_DECISION=1 npm run spike:decision
+# Optional: another Pi model, a subset of scenarios, a per-scenario deadline,
+# and keeping the temp repositories
+SPIKE_DECISION_MODEL=google/gemini-3.1-flash-lite \
+SPIKE_DECISION_SCENARIOS=review,stuck SPIKE_TIMEOUT_MS=600000 SPIKE_KEEP=1 \
+PI_CLAUDE_SUPERVISOR_REAL_DECISION=1 npm run spike:decision
+```
+
+Credentials come only from Pi's own sources (for example `GEMINI_API_KEY` in
+the environment, or `~/.pi/agent/auth.json`); the script never reads, prints or
+stores a key, and redacts what it prints. The scenarios cover:
+- `review`: an incomplete first turn is caught and repaired. Two model
+  behaviors fail it without being regressions: a Reviewer that passes the
+  incomplete turn, and a Decision Worker that answers the "task is complete"
+  turn with `stop`, which ends the task blocked with no repair;
+- `question`: a mid-task question is answered from the spec without a human;
+- `stuck`: a Worker that only claims success ends `blocked` within its repair
+  budget.
+
+The scripted Worker writes the full implementation only after a Supervisor
+message that mentions the RangeError (or min > max). A Decision Worker answer
+that never names it leaves the work undone, and the scenario fails.
+
+Each prints a redacted summary: state, decisions, overrides, Reviewer verdicts
+and answer-format failures. The script exits non-zero when a scenario misses
+its expected outcome. Weak and rate-limited models are useful here, because
+they exercise the deterministic guards that the prompt alone does not
+guarantee. A daily quota error at startup or mid-task is expected to fail
+closed (park), and is not a regression.
+
 The tmux spike is gated, authenticated, and excluded from normal CI. It uses
 plan mode with a fixed `opus` model, records only protocol metadata, and
 verifies three real Claude turns, exact screen-result markers, pause/resume,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-claude-supervisor",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "A policy-gated Pi supervisor for observing and verifying Claude Code workers.",
   "license": "MIT",
   "publishConfig": {
@@ -61,6 +61,7 @@
     "spike:permissions": "node scripts/spike-claude-permissions.mjs",
     "spike:signals": "node scripts/spike-claude-signals.mjs",
     "spike:automation": "node scripts/spike-claude-automation.mjs",
+    "spike:decision": "node scripts/spike-decision.mjs",
     "check": "npm run typecheck && npm test && npm run check:package && npm run check:docs && npm run check:automation",
     "build": "node scripts/build-package.mjs"
   },

package/src/decision-worker.ts

@@ -36,6 +36,8 @@ export interface DecisionContext {
 /** A compact view of the last verification: what failed and what the Reviewer asked for. */
 export interface DecisionVerificationSummary {
   ok: boolean;
+  /** The Worker turn it judged: turns after it are not reflected in it. */
+  atTurn?: number;
   failedChecks: string[];
   reviewVerdict?: string;
   findings: string[];
@@ -92,6 +94,13 @@ export interface DecisionWorkerOptions {
 export type PiModel = NonNullable<NonNullable<Parameters<typeof createAgentSession>[0]>["model"]>;
 
 const DEFAULT_COMPACTION_TOKENS = 60_000;
+/**
+ * Worker turns after a failed verification before the Supervisor verifies on
+ * its own: the Decision Worker only sees that failure as it was, so left to
+ * itself it can keep sending "it still fails" guidance to a Worker that has
+ * already fixed it. The first of these turns is the repair turn itself.
+ */
+export const STALE_VERIFICATION_TURNS = 3;
 /** First retry wait; each later wait triples, capped at MAX_DECISION_RETRY_BACKOFF_MS. */
 const DEFAULT_DECISION_RETRY_BACKOFF_MS = 5_000;
 const MAX_DECISION_RETRY_BACKOFF_MS = 60_000;
@@ -111,6 +120,8 @@ export class PiDecisionWorker implements DecisionWorkerLike {
   #sessionFile?: string;
   #context: DecisionContext;
   readonly #timeoutMs: number;
+  /** Ends a startup retry backoff early; set only while one is waiting. */
+  #wakeStartupBackoff?: () => void;
   readonly #retryBackoffMs: number;
   readonly #compactionTokens: number;
   /** Set after a compaction; the next primary decision prompt re-sends the startup instructions once. */
@@ -163,11 +174,31 @@ export class PiDecisionWorker implements DecisionWorkerLike {
       await this.#options.onSessionReady({ sessionFile: this.#sessionFile, sessionId: session.sessionId, restored });
     }
     if (!restored) {
-      try {
-        await promptForText(session, decisionInstructions(this.#context), this.#timeoutMs, "Decision Worker startup", MAX_DECISION_RESPONSE_BYTES, { role: "decision", onUsage: this.#options.onUsage });
-      } catch (error) {
-        try { await this.#options.onStartupFailure?.(error); } catch { /* preserve the original startup failure */ }
-        throw error;
+      // A provider hiccup (503 overload, 429) here would otherwise fail the
+      // whole task before its first turn: retry it like any decision.
+      const maxRetries = this.#context.spec?.autonomy.maxDecisionRetries ?? DEFAULT_MAX_DECISION_RETRIES;
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          await promptForText(session, decisionInstructions(this.#context), this.#timeoutMs, "Decision Worker startup", MAX_DECISION_RESPONSE_BYTES, { role: "decision", onUsage: this.#options.onUsage });
+          break;
+        } catch (error) {
+          // Closed by the Supervisor (an operator stop): not a startup
+          // failure to report, whatever the interrupted prompt returned.
+          if (this.#closed) throw closedDuringStartup();
+          // Only a provider error is worth another attempt: a timeout already
+          // spent the whole prompt budget and would only multiply it.
+          const retryable = error instanceof Error && error.name === "DecisionWorkerApiError";
+          if (attempt >= maxRetries || !retryable) {
+            try { await this.#options.onStartupFailure?.(error); } catch { /* preserve the original startup failure */ }
+            throw error;
+          }
+          // close() wakes this wait, so a stop does not sit out the backoff.
+          await new Promise<void>((resolveWait) => {
+            const timer = setTimeout(() => { this.#wakeStartupBackoff = undefined; resolveWait(); }, Math.min(MAX_DECISION_RETRY_BACKOFF_MS, this.#retryBackoffMs * 3 ** (attempt + 1)));
+            this.#wakeStartupBackoff = () => { clearTimeout(timer); this.#wakeStartupBackoff = undefined; resolveWait(); };
+          });
+          if (this.#closed) throw closedDuringStartup();
+        }
       }
     }
   }
@@ -300,6 +331,7 @@ export class PiDecisionWorker implements DecisionWorkerLike {
     // Do not await #tail here: onAction may be closing the worker from inside
     // the same queued decision, which would otherwise deadlock shutdown.
     this.#closed = true;
+    this.#wakeStartupBackoff?.();
     const session = this.#session;
     this.#session = undefined;
     if (session) await session.abort().catch(() => {});
@@ -307,6 +339,12 @@ export class PiDecisionWorker implements DecisionWorkerLike {
   }
 }
 
+function closedDuringStartup(): Error {
+  const error = new Error("Decision Worker was closed during startup");
+  error.name = "AbortError";
+  return error;
+}
+
 function decisionInstructions(context: DecisionContext): string {
   return `You are the persistent Pi Decision Worker for a Claude Code implementation task.
 Your job is to inspect evidence and choose the next typed action. Do not edit files,
@@ -338,9 +376,20 @@ means the Worker's own API/model call failed mid-turn: choose retry (optionally
 corrective message) or continue to resume it, and park only after repeated failures; a subtype
 "idle" result means the turn ended without a normal stop signal, so inspect the repository and
 decide as for any other turn. CURRENT CONTEXT.lastVerification, when present, is the last acceptance
-and Review round (failed check ids, Reviewer verdict and findings): after a repair turn, check
-Claude's claim against it before choosing verify. Use verify when a turn result indicates the task is complete, even if
+and Review round (failed check ids, Reviewer verdict and findings) as of Worker turn atTurn. It
+does not change until verification runs again: it is not evidence that the failures remain after
+Claude's later turns. Use it to judge whether Claude's reply addresses those failures; once
+Claude reports them fixed, choose verify rather than re-judging the old result. (After a failed
+verification the Supervisor verifies by itself once ${STALE_VERIFICATION_TURNS} Worker turns, the repair turn included,
+have passed without one; do not rely on it.)
+A continue, redirect or answer message is sent verbatim to Claude Code as its next instruction:
+write it as a direct instruction to Claude, not a description of what you will do yourself (use
+your own read-only tools to inspect the repository before deciding).
+Use verify when a turn result indicates the task is complete, even if
 Claude says it will stop; choose stop only for an explicit stop or technical containment reason.
+In an unattended task without remote authority, a stop on a completed turn stops the Worker
+and then still verifies its work, but no repair round can follow, so a fixable problem would
+be lost: when the work looks done, choose verify.
 Use park only when the task cannot safely produce a candidate because required evidence,
 authority, or runtime capability is unavailable. A parked candidate is asynchronous and must not
 wait for a human to be online. For an exited event choose verify, park or stop; a noop on an exited event is treated as

package/src/redaction.ts

@@ -8,6 +8,21 @@ export function redactSensitive(value: unknown, key?: string): unknown {
   if (typeof value === "string") {
     return value
       .replace(/\b(sk-ant-[A-Za-z0-9_-]+)\b/gu, "[REDACTED]")
+      // sk- and Google API keys, matched by their real shapes so that names
+      // merely starting with "sk-" (a branch sk-1234_fix_login, a path
+      // .../sk-dataset_2024_v2, a CSS class) stay intact: session records and
+      // transcript paths are rejected when redaction changes them.
+      // OpenAI keys (legacy, proj, svcacct, admin) all carry T3BlbkFJ, base64
+      // for "OpenAI"; their base64url bodies may contain - and _.
+      .replace(/(?<![A-Za-z0-9_-])sk-[A-Za-z0-9_-]*T3BlbkFJ[A-Za-z0-9_-]*/gu, "[REDACTED]")
+      // OpenRouter: sk-or-v1- and 64 hex digits.
+      .replace(/(?<![A-Za-z0-9_-])sk-or-v1-[0-9a-f]{64}(?![A-Za-z0-9_-])/gu, "[REDACTED]")
+      // Other sk- providers (DeepSeek, Moonshot, …): 32+ letters and digits,
+      // with both. Accepted cost: a name that is exactly sk- and such a run
+      // (sk-<git sha>) cannot be told from a DeepSeek key and is redacted.
+      .replace(/(?<![A-Za-z0-9_-])sk-(?=[A-Za-z]*[0-9])(?=[0-9]*[A-Za-z])[A-Za-z0-9]{32,}(?![A-Za-z0-9_-])/gu, "[REDACTED]")
+      .replace(/(?<![A-Za-z0-9_-])AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])/gu, "[REDACTED]")
+      .replace(/(?<![A-Za-z0-9_-])AQ\.[A-Za-z0-9_-]{40,}/gu, "[REDACTED]")
       .replace(/\b(?:gh[pousr]_[A-Za-z0-9_]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{20,}|npm_[A-Za-z0-9]{20,})\b/gu, "[REDACTED]")
       .replace(/\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/gu, "[REDACTED]")
       .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[REDACTED]")

package/src/supervisor.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { EventLog, type SupervisorEvent } from "./events.ts";
 import { SupervisorStateMachine } from "./state.ts";
 import { evaluatePermission, isCommitId, isProtectedBranch, isRoutinePermission, publishCommand, pullRequestCommand, type PermissionPolicyOptions, type PolicyResult, type RemoteGrant } from "./policy.ts";
-import { PiDecisionWorker, type DecisionAction, type DecisionContext, type DecisionDeadlineContext, type DecisionWorkerFactory, type DecisionWorkerLike, type PiModel } from "./decision-worker.ts";
+import { PiDecisionWorker, STALE_VERIFICATION_TURNS, type DecisionAction, type DecisionContext, type DecisionDeadlineContext, type DecisionWorkerFactory, type DecisionWorkerLike, type PiModel } from "./decision-worker.ts";
 import { DEFAULT_DEADLINE_GRACE_MS, DEFAULT_DEADLINE_MS, DEFAULT_DEADLINE_WARNING_MS, DEFAULT_NO_OUTPUT_TIMEOUT_MS, formatDurationMs } from "./config.ts";
 import { collectRepositoryEvidence, remoteBranchHead, remoteUrl, runReadOnly, repositoryBranch, repositoryCommitExists, repositoryHead, repositoryIsAncestor, repositoryWorkTree, verifyAll, repositoryClean, repositoryGitDirectoryIsLocal, repositorySlug, sameDestination, type RemoteBranchLookup, type RemoteDestination, type RepositoryEvidence, type VerificationCommand } from "./verifier.ts";
 import { normalizeTaskSpec } from "./acceptance.ts";
@@ -214,6 +214,10 @@ export class Supervisor {
   #lastObservedBranch?: string;
   #handle?: WorkerHandle;
   #lastVerification?: AcceptanceReport;
+  /** The Worker turn the last verification judged; later turns are not reflected in it. */
+  #lastVerificationTurn?: number;
+  /** Set when a Decision Worker `stop` became a verification: no repair turn may follow it. */
+  #stopVerification?: string;
   #workerOutput = "";
   #lastWorkerResult?: Record<string, unknown>;
   #lastTurnCompleted?: WorkerEvent;
@@ -352,6 +356,8 @@ export class Supervisor {
     this.#handle = undefined;
     this.#lastObservedBranch = undefined;
     this.#lastVerification = undefined;
+    this.#lastVerificationTurn = undefined;
+    this.#stopVerification = undefined;
     this.#workerOutput = "";
     this.#lastWorkerResult = undefined;
     this.#lastTurnCompleted = undefined;
@@ -1083,6 +1089,7 @@ export class Supervisor {
       if (action.action === "continue" || action.action === "redirect" || action.action === "answer") {
         if (await this.#decisionIsStale(event)) return;
         if (await this.#verifyOnTurnBudget(handle, event, action)) return;
+        if (await this.#verifyStaleFailure(handle, event, action)) return;
         await this.#sendInternal(action.message);
         return;
       }
@@ -1136,6 +1143,7 @@ export class Supervisor {
         return;
       }
       if (action.action === "stop") {
+        if (await this.#verifyStop(handle, event, action)) return;
         await this.#stopInternal(`Decision Worker: ${action.reason}`);
         return;
       }
@@ -1145,6 +1153,7 @@ export class Supervisor {
         const message = action.message?.trim() ? action.message : RETRY_RESUME_MESSAGE;
         if (await this.#decisionIsStale(event)) return;
         if (await this.#verifyOnTurnBudget(handle, event, action)) return;
+        if (await this.#verifyStaleFailure(handle, event, action)) return;
         await this.#sendInternal(message);
       }
     });
@@ -1162,6 +1171,53 @@ export class Supervisor {
     return true;
   }
 
+  /**
+   * A verification failed and the Worker has since taken several turns with
+   * no new one: judge the work as it is now instead of sending more guidance
+   * based on the old failure. Another failure goes through the ordinary
+   * repair-round budget, so a stuck task parks instead of running to its
+   * deadline.
+   */
+  async #verifyStaleFailure(handle: WorkerHandle, event: WorkerEvent, action: DecisionAction): Promise<boolean> {
+    if (event.type !== "turn_completed" || !this.#lastVerification || this.#lastVerification.ok || this.#lastVerificationTurn === undefined) return false;
+    // A turn cut short by the Worker's own API error is half-done work: let
+    // the Decision Worker resume it rather than judging it.
+    if (event.result.is_error === true || event.result.subtype === "error") return false;
+    const turnsSince = this.#turn - this.#lastVerificationTurn;
+    if (turnsSince < STALE_VERIFICATION_TURNS) return false;
+    await this.#appendEvent({ type: "decision_overridden", taskId: this.#task?.taskId, workerId: handle.id, data: { action: action.action, override: "verify", reason: `${turnsSince} Worker turns since the last failed verification`, eventType: event.type } }).catch(() => {});
+    await this.#startVerification(handle, event, "stale failed verification");
+    return true;
+  }
+
+  /**
+   * An unattended `stop` on a finished turn: models reach for it when they
+   * believe the work is done, and a plain stop would end the task unverified
+   * with its work unreported. The stop still happens first — the Worker is
+   * stopped and never kept open — and then its finished work is judged
+   * (acceptance and the Reviewer only read): a failure blocks the candidate
+   * rather than starting a repair round. A stop elsewhere (a pending
+   * permission, a turn the Worker has already resumed) or on a task that may
+   * publish stays a plain stop.
+   */
+  async #verifyStop(handle: WorkerHandle, event: WorkerEvent, action: DecisionAction): Promise<boolean> {
+    const task = this.#task;
+    if (!task || !this.#automation || this.#humanRequired || event.type !== "turn_completed" || this.#machine.state !== "waiting") return false;
+    if (task.spec.autonomy.remoteAuthority !== "none") return false;
+    if (await this.#decisionIsStale(event)) return false;
+    this.#stopVerification = action.reason;
+    await this.#appendEvent({ type: "decision_overridden", taskId: task.taskId, workerId: handle.id, data: { action: action.action, override: "verify", reason: "the Worker is stopped and its finished work verified before the task ends; no further Worker turns", decisionReason: action.reason, eventType: event.type } }).catch(() => {});
+    await this.#adapter.stop(handle, `Decision Worker: ${action.reason}`);
+    await this.#pollInternal(true);
+    // Re-read after the awaits: the poll moves the stopped Worker on.
+    const after: string = this.#machine.state;
+    // An operator stop arrived meanwhile: it owns the outcome ("stopped").
+    if (this.#stopRequested !== undefined) return true;
+    if (after === "verifying") await this.#verifyInternal();
+    else await this.#parkCandidate(`Decision Worker stop left the task in state ${after} before verification`, event);
+    return true;
+  }
+
   /**
    * Move an idle Worker into verification the way a `verify` decision does:
    * in place when the transport supports it, otherwise by stopping the
@@ -1636,6 +1692,7 @@ export class Supervisor {
     if (!this.#task) throw new Error("no active task");
     if (this.#machine.state === "waiting" && canRepairInPlace(this.#adapter)) this.#machine.transition("verifying");
     if (this.#machine.state !== "verifying") throw new Error(`cannot verify from ${this.#machine.state}`);
+    this.#lastVerificationTurn = this.#turn;
     const verificationAbortController = new AbortController();
     this.#verificationAbortController = verificationAbortController;
 
@@ -2194,6 +2251,10 @@ export class Supervisor {
     const task = this.#task;
     const handle = this.#handle;
     if (!task || !this.#automation || this.#humanRequired) return false;
+    if (this.#stopVerification !== undefined) {
+      await this.#appendEvent({ type: "candidate_blocked", taskId: task.taskId, workerId: handle?.id, data: { reason: `${reason}; the Decision Worker chose stop, so no repair round is sent` } });
+      return false;
+    }
     if (this.#repairRound >= task.spec.maxRepairRounds) {
       await this.#appendEvent({ type: "repair_round_exhausted", taskId: task.taskId, workerId: handle?.id, data: { maxRepairRounds: task.spec.maxRepairRounds, reason } });
       await this.#appendEvent({ type: "candidate_blocked", taskId: task.taskId, workerId: handle?.id, data: { reason: `${reason}; automatic repair budget is exhausted` } });
@@ -2263,7 +2324,7 @@ export class Supervisor {
     // A completed interactive task may keep its persistent session open for
     // the operator instead of tearing it down; a stop requested mid-verify or
     // a blocked/failed outcome always falls back to today's stop behavior.
-    const keepOpen = !stopRequested && outcome === "completed" && result.ok
+    const keepOpen = !stopRequested && this.#stopVerification === undefined && outcome === "completed" && result.ok
       && this.#keepWorkerOnCompletion && Boolean(this.#adapter.release) && Boolean(this.#handle);
     let cleanupError: unknown;
     let releasedInteractive = false;
@@ -2577,6 +2638,7 @@ export class Supervisor {
     // Worker judges a repair turn only by Claude's claim that it is done.
     const lastVerification = verification ? {
       ok: verification.ok,
+      ...(this.#lastVerificationTurn !== undefined ? { atTurn: this.#lastVerificationTurn } : {}),
       failedChecks: verification.checks.filter((check) => check.check.required && !check.ok).map((check) => check.check.id).slice(0, 16),
       ...(verification.review ? { reviewVerdict: verification.review.verdict } : {}),
       findings: bySeverity(verification.review?.findings ?? []).slice(0, 8).map((finding) => `${finding.id} [${finding.severity}] ${finding.message}`.slice(0, 200)),