@staix/agent-hub 0.25.0 → 0.26.0

package/src/hub/sdlc-queue.ts

@@ -4,7 +4,14 @@ import { evalGapBlockers, evalGateView, readEvalFor, type EvalGate } from "./eva
 import { findingsForHead, findingHead, findingTally, type ReviewFindingSet, type ReviewFindingTally } from "./review-findings.ts";
 import type { CriteriaView } from "./workflow.ts";
 import { parsePrEvidence, readSdlcPr, sdlcGh, sdlcStatus, type PrEvidence, type SdlcConfig, type SdlcGh, type SdlcReceipt } from "./sdlc.ts";
-export interface DeliveryTask { plan?: { paths?: string[]; revision: number; fingerprint: string; accepted: { repo: string; pr: number; head: string; revision: number; fingerprint: string; paths: string[] }[] }; findings?: readonly ReviewFindingSet[]; id: number; after: number[]; private: boolean; receipt?: SdlcReceipt; phase?: CriteriaView; }
+export interface DeliveryTask {
+  /** Latest owner-reported artifact head; omitted by older library callers. */
+  latestHead?: string;
+  /** Host-derived verdict binding, never inferred from a mutable lifecycle receipt. */
+  approval?: { head?: string; latestHead?: string; mismatch: boolean; current: boolean };
+  plan?: { paths?: string[]; revision: number; fingerprint: string; accepted: { repo: string; pr: number; head: string; revision: number; fingerprint: string; paths: string[] }[] };
+  findings?: readonly ReviewFindingSet[]; id: number; after: number[]; private: boolean; receipt?: SdlcReceipt; phase?: CriteriaView;
+}
 export interface MergeQueueRow { evalGate?: EvalGate; testIntegrity?: (TestIntegrity & { task?: number })[]; planConformance?: { task?: number; state: string; outside: number; untouched: number; accepted: boolean }[]; findings?: ReviewFindingTally; pr: number; tasks: number[]; head?: string; private?: true; ready: boolean; blockers: string[]; after: number[]; }
 export interface MergeConflict { left: number; right: number; files: number; order: "dependency" | "person_required"; }
 export interface MergeQueue { repo: string; rows: MergeQueueRow[]; order: number[]; unordered?: number[]; conflicts: MergeConflict[]; complete: boolean; truncated: boolean; }
@@ -94,6 +101,11 @@ export async function readMergeQueue(repo: string, config: SdlcConfig, tasks: De
       const integrity = rawIntegrity ? publicTestIntegrity(rawIntegrity, readableMetadata) : undefined;
       if (integrity) (row.testIntegrity ??= []).push({ task: holder!.id, ...integrity });
       row.blockers.push(...sdlcStatus(config, holder?.receipt, read, holder?.phase).blockers);
+      const approved = holder?.receipt?.reviewedHead, binding = holder?.approval;
+      if (holder?.latestHead !== undefined && holder.latestHead !== approved) row.blockers.push("latest reported head differs from approved head");
+      if (binding && (!binding.current || binding.mismatch || !binding.head || binding.head !== approved
+        || holder?.latestHead !== undefined && binding.head !== holder.latestHead
+        || binding.latestHead !== undefined && binding.head !== binding.latestHead)) row.blockers.push("approval is not current at the latest reported head");
       // #481 S5: the eval check itself is a required check inside sdlcStatus; its recorded pass rate and suite are read once per PR here.
       if (!row.evalGate) {
         const gate = evalGateView(config, read, await readEvalFor(config, read, repo, bounded));

package/src/hub/settings.ts

@@ -12,6 +12,7 @@ import { CLASSES, type TaskClass } from "./board.ts";
 import { configTracked, configRepositoryPresent } from "./config-trust.ts";
 import { PERMISSION_MODES, permissionBoundary } from "./permission-mode.ts";
 import { START_MODES } from "./start-mode.ts";
+import { checkStartAgents } from "./start-agents.ts";
 import { OVERLAY_FILE, overlayToml, parseOverlay, parseRouting, routingText, type Routing, type RoutingOverlay } from "./routing.ts";
 
 /**
@@ -74,6 +75,7 @@ export const SETTINGS: readonly SettingDef[] = [
   ...ACTION_CLASSES.map((kind): SettingDef => ({ key: `action_policy.budgets.${kind}`, group: "Permissions", label: `${kind}: approved session budget`, type: "integer", min: 0, max: 1000, store: "config", applies: "live", risk: "raises", floor: 0, path: ["action_policy", "budgets", kind] })),
   ...SETTING_PEERS.filter(peer => !definitionOf(peer)?.permission.unmanaged).map((peer): SettingDef => ({ key: `permission.${peer}`, group: "Permissions", label: `${peer}: mode now`, type: "enum", values: PERMISSION_MODES, store: "runtime", applies: "live", risk: "raises", floor: "ask", path: [peer] })),
   ...SETTING_PEERS.filter(peer => !definitionOf(peer)?.permission.unmanaged).map((peer): SettingDef => ({ key: `permission_modes.${peer}`, group: "Permissions", label: `${peer}: mode at next peer start`, type: "enum", values: PERMISSION_MODES, store: "config", applies: "next use", risk: "raises", floor: "ask", path: ["permission_modes", peer] })),
+  { key: "start.agents", group: "Start", label: "Agents ahub up starts (none for an empty list)", type: "peers", store: "config", applies: "next use", risk: "raises", path: ["start", "agents"] },
   ...START_MODE_PEERS.map((peer): SettingDef => ({ key: `peers.${peer}.start_mode`, group: "Start", label: `${peer}: start mode (tui unless set)`, type: "enum", values: START_MODES, store: "config", applies: "next use", risk: "raises", floor: "tui", path: ["peers", peer, "start_mode"] })),
   ...ADAPTERS.flatMap(adapter => adapter.configuration?.settings ?? []),
   { key: "routing.stay_switch", group: "Routing", label: "Stay or switch (hub/auto and stage routes)", type: "enum", values: ["off", "shadow", "enforce"], store: "routing", applies: "live", risk: "raises", path: ["stay_switch"] },
@@ -203,6 +205,7 @@ export function checkSettingValue(def: SettingDef, raw: unknown, routes: readonl
       }
       return peers.length === 1 ? peers[0] as string : [...peers] as string[];
     }
+    if (def.key === "start.agents") return checkStartAgents(raw, def.key);
     if (!Array.isArray(raw) || raw.length > PEERS_MAX || raw.some((p) => typeof p !== "string" || !PEER.test(p)) || new Set(raw).size !== raw.length) throw new Error(`${def.key} takes up to ${PEERS_MAX} distinct peer ids`);
     return [...(raw as string[])];
   }
@@ -217,6 +220,7 @@ export function parseSettingText(def: SettingDef, text: string): unknown {
   if (def.type === "number") return text.trim() && Number.isFinite(Number(text)) ? Number(text) : text;
   if (def.type === "integer") return /^(0|[1-9]\d*)$/.test(text) ? Number(text) : text;
   if (def.type === "boolean") return text === "true" ? true : text === "false" ? false : text;
+  if (def.key === "start.agents" && text.trim() === "none") return [];
   if (def.type === "peers" || def.type === "roles") return text.split(",").map((p) => p.trim()).filter(Boolean);
   return text;
 }

package/src/hub/snapshots.ts

@@ -1,4 +1,5 @@
-import { Database } from "bun:sqlite";
+import type { Database } from "./db-schema.ts";
+import { openHubDatabase } from "./db-schema.ts";
 import { closeSync, constants, copyFileSync, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, rmSync, statSync, utimesSync, writeFileSync, type Stats } from "node:fs";
 import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
@@ -7,7 +8,6 @@ import { childEnv } from "./child-process.ts";
 import type { Touch } from "./conflicts.ts";
 import { hubGitSync } from "./git.ts";
 import { realPath } from "./project.ts";
-import { HUB_DB_BUSY_TIMEOUT_MS } from "./db-timeout.ts";
 
 /**
  * Per-turn workspace snapshots (issue #33): git tree objects written through a copy of the index, so the user's index
@@ -657,8 +657,7 @@ export function submodulePaths(repo: Repo): string[] {
 export class Turns {
   private readonly db: Database;
   constructor(path: string, readonly?: boolean) {
-    this.db = new Database(path, readonly ? { readonly: true } : { create: true });
-    this.db.run(`PRAGMA busy_timeout = ${HUB_DB_BUSY_TIMEOUT_MS}`);
+    this.db = openHubDatabase(path, readonly ? { readonly: true } : { create: true });
     if (readonly) return;
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run(`CREATE TABLE IF NOT EXISTS turns (id TEXT PRIMARY KEY, peer TEXT NOT NULL, started INTEGER NOT NULL, ended INTEGER,

package/src/hub/start-agents.ts

@@ -0,0 +1,44 @@
+import { SUPPORTED_PEERS, definitionOf } from "../adapters/registry.ts";
+
+/**
+ * #608 (agent-hub#1040): the agents `ahub up` asks the hub to start, `start.agents`. Pure and free of file-system
+ * imports: the config schema (`config-apply.ts`) reaches the Claude channel bundle. The list is read by the CLI at a
+ * person's `ahub up` and by the dashboard manager's start; the daemon never reads it, so a restart, a crash recovery,
+ * a reload or an upgrade relaunch starts nothing from it.
+ *
+ * Which kinds may be listed, which are in the default set and why a kind is refused all come from the kind's own
+ * `AdapterDefinition.start.upStart` (#451): nothing here names a peer.
+ */
+const upStart = (id: string) => definitionOf(id)?.start.upStart;
+
+/** The kinds in the default set, in the registry's order. */
+export const START_AGENTS_DEFAULT: readonly string[] = Object.freeze(SUPPORTED_PEERS.filter(peer => { const s = upStart(peer); return s?.allowed === true && s.default === true; }));
+export const START_AGENTS_MAX = 8;
+const PEER = /^[a-z][a-z0-9-]{0,31}$/;
+
+/** The kinds `ahub up` may start. A declared instance, a channel extra and an unknown id are never in it. */
+export const START_AGENTS_ALLOWED: readonly string[] = Object.freeze(SUPPORTED_PEERS.filter(peer => definitionOf(peer)?.start.conductorStartable === true && upStart(peer)?.allowed === true));
+
+/** Why `id` cannot be in the start set, or undefined. The reason never repeats the id unless it is a well-formed peer id. */
+export function startAgentRefusal(id: unknown): string | undefined {
+  if (typeof id !== "string" || !PEER.test(id)) return "an entry is not a peer id (lowercase letters, digits and dashes)";
+  if (START_AGENTS_ALLOWED.includes(id)) return undefined;
+  const own = upStart(id);
+  if (own?.allowed === false) return `${id} cannot be started by ahub up: ${own.refusal}`;
+  if (SUPPORTED_PEERS.includes(id)) return `${id} cannot be started by ahub up: the hub does not start it; run ahub ${id} in a terminal`;
+  return `${id} cannot be started by ahub up: it is a declared instance, a channel extra or unknown, and only ${START_AGENTS_ALLOWED.join(", ")} are started by the hub`;
+}
+
+/** The checked list (a copy), or a thrown reason. An empty list is allowed and starts nothing. */
+export function checkStartAgents(raw: unknown, key = "start.agents"): string[] {
+  if (!Array.isArray(raw) || raw.length > START_AGENTS_MAX) throw new Error(`${key} takes a list of up to ${START_AGENTS_MAX} peer ids (an empty list starts none)`);
+  for (const id of raw) { const why = startAgentRefusal(id); if (why) throw new Error(`${key}: ${why}`); }
+  if (new Set(raw).size !== raw.length) throw new Error(`${key} takes distinct peer ids`);
+  return [...raw] as string[];
+}
+
+/** A person's text for the list: commas or spaces between ids, `none` for an empty list. */
+export function parseStartAgents(text: string): string[] {
+  const words = text.split(/[\s,]+/).filter(Boolean);
+  return checkStartAgents(words.length === 1 && words[0] === "none" ? [] : words);
+}

package/src/hub/task-approval.ts

@@ -0,0 +1,23 @@
+import type { Task } from "./board.ts";
+
+export interface ApprovalBinding { head?: string; latestHead?: string; mismatch: boolean; current: boolean }
+const fullHead = (value: unknown): string | undefined => typeof value === "string" && /^[a-f0-9]{40}$/.test(value) ? value : undefined;
+
+/** The last approval remains historical evidence after a new delivery or a withdrawal. Unknown legacy heads stay unknown. */
+export function approvalBinding(task: Task): ApprovalBinding | undefined {
+  const verdict = task.history.findLast(entry => entry.event === "approved");
+  if (!verdict) return undefined;
+  const head = fullHead(verdict.reviewedHead) ?? fullHead(verdict.reviewFindings?.head)
+    ?? (task.state === "approved" ? fullHead(task.sdlc?.reviewedHead) : undefined);
+  const latestHead = fullHead(task.refs.commit ?? task.sdlc?.head ?? task.sdlc?.localHead);
+  const mismatch = !!head && !!latestHead && head !== latestHead;
+  return { ...(head ? { head } : {}), ...(latestHead ? { latestHead } : {}), mismatch,
+    current: task.state === "approved" && !!head && head === latestHead };
+}
+
+export function approvalText(binding: ApprovalBinding | undefined): string {
+  if (!binding) return "";
+  return `Approval bound to head ${binding.head ?? "unknown"}; latest reported head ${binding.latestHead ?? "unknown"}. ${binding.mismatch
+    ? "HEAD MISMATCH: earlier approval does not approve the latest reported head."
+    : binding.current ? "Approval is current at this head." : "Earlier approval is not current; review is required."}`;
+}

package/src/hub/tasks.ts

@@ -1,3 +1,5 @@
+import { parseAttemptReceipt, parseResearchRunners, verifyAttemptReceipt } from "./research-runner.ts";
+import { approvalBinding, approvalText } from "./task-approval.ts";
 import type { InvocationRow } from "./invocations.ts";
 import type { ContextAdmission } from "./context-window.ts";
 import { queueBackpressure, queueBackpressurePolicy, type QueueBackpressureCode, type QueueBackpressurePolicy, type QueueBackpressureStatus, type QueuePressure } from "./queue-backpressure.ts";
@@ -5,7 +7,7 @@ import { canonicalMemorySymbolNode, normalizeMemorySymbolInput, MEMORY_SYMBOL_LI
 import { createHash, randomBytes } from "node:crypto";
 import { types } from "node:util";
 import { canonicalJson } from "./packs.ts";
-import { parseExperimentProtocol, parseExperimentAttempt, parseExperimentEvent, protocolHash, checkRunObservation, deliverableObservation, projectExperimentWithObservations,
+import { parseExperimentProtocol, parseExperimentAttempt, parseExperimentEvent, protocolHash, checkRunObservation, deliverableObservation, projectExperimentWithObservations, projectRunnerReceipt,
   type ExperimentProtocolContract, type ExperimentProtocolRecord, type ExperimentAttemptRecord, type ExperimentWriteFence, type ExperimentHostEvidence, type ExperimentStatus } from "./research-experiments.ts";
 import { parseComparisonPlan, comparisonPlanHash, comparisonProjection, evaluatorIdentityHash, protocolApprovalBindingMatches, type ComparisonPlanV1 } from "./research-experiments.ts";
 import { parseResearchHandoff, studyProjection, campaignHash, parseResearchCampaign, type ResearchCampaignContract, type ResearchCampaignStatus } from "./research-campaign.ts";
@@ -190,6 +192,8 @@ export interface TasksDeps {
   studyNow?: () => number;
   /** Host-only reader for this project's check-runner receipts; record inputs never supply a receipt. */
   experimentCheck?: (run: string) => Promise<unknown>;
+  /** Fresh trusted machine-local runner registrations. A source-trust failure refuses new receipts. */
+  researchRunners?: () => unknown;
   /** Reviewer choice from recorded review outcomes (issue #35); off unless the project config turns it on. */
   review?: { adaptive: boolean; min_reviews: number; pool?: readonly string[]; rerotate?: boolean; same_family?: "fallback" | "never" };
   /** Peers whose recent deliveries all failed, with the reason (issue #89); routing skips them. */
@@ -393,7 +397,7 @@ export const GROOM_FYI_WINDOW_MS = 10 * 60_000;
 /** #694: a PR staged at done with the commit or branch it was read for. */
 export interface ResearchCampaignReceipt { id: string; parentTaskId: number; revision: number; status: ResearchCampaignStatus; unitCount: number; units: ResearchUnitBinding[] }
 interface StudyReferences { parent: Task; adopted: Map<string, Task>; reused: Map<string, Task>; private: boolean; key: string }
-export interface ExperimentReceipt { kind: "protocol" | "attempt" | "event"; protocolHash: string; attemptId?: string; seq?: number }
+export interface ExperimentReceipt { kind: "protocol" | "attempt" | "event" | "receipt"; protocolHash: string; attemptId?: string; seq?: number; receiptId?: string }
 export interface ComparisonPlanReceipt { kind: "plan"; planHash: string }
 export interface ProtocolApprovalReceipt { protocolHash: string; evaluatorHash: string; approvedBy: string; approvedAt: number }
 export interface ExperimentAttemptView {
@@ -405,7 +409,7 @@ export interface ExperimentAttemptView {
 export interface ExperimentView { attempts: ExperimentAttemptView[]; counts: { all: number; statuses: Record<ExperimentStatus, number> }; nextCursor?: number;
   comparison?: { planHash: string; baselineAttemptId: string; variantAttemptId: string; approved: boolean; private: boolean; projection: ReturnType<typeof comparisonProjection> | "[pii]" } }
 interface ExperimentContext { task: Task; campaign: ResearchCampaignRecord; private: boolean; key: string; fence: ExperimentWriteFence }
-interface CompletionRefresh { revision: number; commit: string }
+interface CompletionRefresh { revision: number; commit: string; state: "in_review" | "approved" }
 interface IdentityLink { repo: string; pr: number; basis: { commit?: string; branch?: string } }
 
 /** What one live check of a task's files says as a whole (#317): `unchanged` only when EVERY file measured unchanged. A change outranks a missing file, which outranks one the hub could not read. */
@@ -918,6 +922,7 @@ export class Tasks {
       ...(h.selfReview ? { selfReview: true } : {}),
       ...(h.reviewerFamily ? { reviewerFamily: screenHistoryText(h.reviewerFamily, "reviewer family") } : {}),
       ...(h.reviewerReason ? { reviewerReason: h.reviewerReason } : {}),
+      ...(h.reviewedHead ? { reviewedHead: h.reviewedHead } : {}),
       ...(h.reviewScope === "code" ? { reviewScope: "code" as const } : {}),
       ...(h.evidenceOnly ? { evidenceOnly: true as const } : {}),
       ...(h.unmetCriteria?.length ? { unmetCriteria: h.unmetCriteria } : {}),
@@ -933,7 +938,7 @@ export class Tasks {
     const symbolRepository = codeSymbols && this.codeSymbolsRepository(task);
     const publicSymbols = codeSymbols && symbolRepository ? publicTaskCodeSymbols(codeSymbols, this.reviewHead(task), symbolRepository.key, this.publicMetadataText) : undefined;
     const handedOff = this.d.board.handoffOrigin(task.id);   // #604: where another project's handoff came from; two ids, never text
-    return { ...rest, ...(handedOff ? { handoffOrigin: { projectId: handedOff.projectId, peer: handedOff.peer, ...(handedOff.originTask === null ? {} : { task: handedOff.originTask }) } } : {}), ...(publicSymbols ? { codeSymbols: publicSymbols } : {}), ...(current.length ? { findings: findingTally(current) } : {}), ...(cancelled ? { cancelled: { ...cancelled, reason: screenHistoryText(cancelled.reason, "cancellation", cancelled.withheld), ...(cancelled.supersededBy ? { supersededBy: screenHistoryText(cancelled.supersededBy, "supersession", cancelled.withheld) } : {}) } } : {}), ...(external && this.nameable(external.url) ? { external } : {}), actualDates: actualTaskDates(task), ...(((this.d.sdlc?.config().mode ?? "off") !== "off" || this.d.sdlc?.config().workflow === "gsd-lite") ? { lifecycle: sdlcStatus(this.d.sdlc?.config() ?? sdlcConfig(undefined), task.sdlc, undefined, this.workflowView(task), undefined, sets, task.refs.commit) } : {}), title, detail, history: publicHistory };
+    return { ...rest, ...(approvalBinding(task) ? { approval: approvalBinding(task) } : {}), ...(handedOff ? { handoffOrigin: { projectId: handedOff.projectId, peer: handedOff.peer, ...(handedOff.originTask === null ? {} : { task: handedOff.originTask }) } } : {}), ...(publicSymbols ? { codeSymbols: publicSymbols } : {}), ...(current.length ? { findings: findingTally(current) } : {}), ...(cancelled ? { cancelled: { ...cancelled, reason: screenHistoryText(cancelled.reason, "cancellation", cancelled.withheld), ...(cancelled.supersededBy ? { supersededBy: screenHistoryText(cancelled.supersededBy, "supersession", cancelled.withheld) } : {}) } } : {}), ...(external && this.nameable(external.url) ? { external } : {}), actualDates: actualTaskDates(task), ...(((this.d.sdlc?.config().mode ?? "off") !== "off" || this.d.sdlc?.config().workflow === "gsd-lite") ? { lifecycle: sdlcStatus(this.d.sdlc?.config() ?? sdlcConfig(undefined), task.sdlc, undefined, this.workflowView(task), undefined, sets, task.refs.commit) } : {}), title, detail, history: publicHistory };
   }
 
   /** Console results expose direct approval and delivery holds, not just the chosen peer ids. */
@@ -1891,13 +1896,43 @@ export class Tasks {
 
   /** Record evidence only: this path never runs a check, a shell command or a runner. */
   async experimentRecord(by: PeerId, input: { kind: "plan"; [key: string]: unknown }): Promise<ComparisonPlanReceipt>;
-  async experimentRecord(by: PeerId, input: { kind: "protocol" | "attempt" | "event"; [key: string]: unknown }): Promise<ExperimentReceipt>;
+  async experimentRecord(by: PeerId, input: { kind: "protocol" | "attempt" | "event" | "receipt"; [key: string]: unknown }): Promise<ExperimentReceipt>;
   async experimentRecord(by: PeerId, input: unknown): Promise<ExperimentReceipt | ComparisonPlanReceipt>;
   async experimentRecord(by: PeerId, input: unknown): Promise<ExperimentReceipt | ComparisonPlanReceipt> {
     const requestCheck = this.requestCheck(by, () => this.studyHold());
-    const envelope = this.studyFields(input, ["kind", "taskId", "protocol", "attempt", "attemptId", "idempotencyKey", "event", "plan"]);
+    const envelope = this.studyFields(input, ["kind", "taskId", "protocol", "attempt", "attemptId", "idempotencyKey", "event", "plan", "receipt", "signature"]);
     return this.studyWrite(async () => {
       try {
+        if (envelope.kind === "receipt") {
+          const fields = this.studyFields(input, ["kind", "receipt", "signature"]), receipt = parseAttemptReceipt(fields.receipt);
+          const attempt = this.experimentAttempt(receipt.attemptId), record = this.experimentProtocol(attempt.attempt.protocolHash);
+          const relayOwner = by === USER ? this.studyParent(attempt.attempt.taskId).owner : by;
+          if (!relayOwner) throw new PreEffectToolRefusal("receipt relay requires a current task owner");
+          const before = this.experimentContext(relayOwner, attempt.attempt.taskId, record.protocol, record.recordedForTaskId);
+          requestCheck();
+          const proof = (stored: NonNullable<ReturnType<Board["runnerReceipt"]>>): ExperimentReceipt => ({ kind: "receipt", protocolHash: record.hash,
+            attemptId: attempt.attemptId, seq: stored.seq, receiptId: receipt.receiptId });
+          const known = this.d.board.runnerReceipt(receipt.receiptId);
+          if (known) {
+            if (canonicalJson(known.receipt) !== canonicalJson(receipt) || known.signature !== fields.signature)
+              throw new PreEffectToolRefusal("receiptId already records different signed bytes");
+            this.experimentFresh(before, relayOwner, record.protocol, record.recordedForTaskId); requestCheck();
+            return proof(known); // immutable stored proof: do not re-verify against a revoked/replaced registration or write on replay
+          }
+          const registrations = parseResearchRunners(this.d.researchRunners?.() ?? {}), registrationKey = canonicalJson(registrations);
+          const context = { projectId: this.d.project, attempt: { id: attempt.attemptId, projectId: attempt.project, protocolHash: attempt.attempt.protocolHash,
+            ...("commit" in record.protocol.code ? { codeCommit: record.protocol.code.commit } : {}) } };
+          verifyAttemptReceipt(receipt, fields.signature, { ...context, runners: registrations });
+          const lastSeq = this.d.board.experimentLastSeq(attempt.attemptId);
+          await this.experimentScreen(canonicalJson(receipt), before.task); requestCheck();
+          const current = this.experimentFresh(before, relayOwner, record.protocol, record.recordedForTaskId);
+          const latest = parseResearchRunners(this.d.researchRunners?.() ?? {});
+          if (canonicalJson(latest) !== registrationKey) throw new PreEffectToolRefusal("runner registration changed during receipt admission");
+          verifyAttemptReceipt(receipt, fields.signature, { ...context, runners: latest }); requestCheck();
+          const saved = this.d.board.appendRunnerReceipt({ receipt, signature: fields.signature as string, publicKey: latest[receipt.runner]!.publicKey,
+            by, at: this.studyTime(), private: current.private || record.private || attempt.private }, lastSeq, current.fence);
+          return proof(saved);
+        }
         if (envelope.kind === "plan") {
           const fields = this.studyFields(input, ["kind", "taskId", "plan"]), taskId = this.studyNumber(fields.taskId, "taskId"), plan = parseComparisonPlan(fields.plan);
           const before = this.experimentPlanContext(by, taskId, plan);
@@ -1970,6 +2005,17 @@ export class Tasks {
     });
   }
 
+  private runnerKeyStatus(stored: NonNullable<ReturnType<Board["runnerReceipt"]>>): "active" | "revoked" | "replaced" | "unavailable" {
+    try {
+      const runners = parseResearchRunners(this.d.researchRunners?.() ?? {});
+      if (!Object.hasOwn(runners, stored.receipt.runner)) return "unavailable";
+      const current = runners[stored.receipt.runner]!;
+      if (current.publicKey !== stored.publicKey) return "replaced";
+      if (current.revoked) return "revoked";
+      return current.projects.includes(stored.receipt.projectId) ? "active" : "unavailable";
+    } catch { return "unavailable"; }
+  }
+
   private experimentPrivate(record: ExperimentProtocolRecord, attempt: ExperimentAttemptRecord): boolean {
     try {
       const campaign = this.d.board.researchCampaign(record.protocol.campaignId, record.protocol.campaignRevision), task = this.d.board.get(attempt.attempt.taskId);
@@ -2025,17 +2071,20 @@ export class Tasks {
     const summary = this.d.board.experimentSummary(this.d.project, campaignId), views: ExperimentAttemptView[] = [];
     for (const attempt of attempts) {
       const record = this.experimentProtocol(attempt.attempt.protocolHash), page = this.d.board.experimentEvents(attempt.attemptId, eventAfter, limit);
-      const privateRecord = this.experimentPrivate(record, attempt) || page.rows.some(row => row.private);
+      const runnerReceipts = this.d.board.runnerReceipts(attempt.attemptId);
+      const privateRecord = this.experimentPrivate(record, attempt) || page.rows.some(row => row.private)
+        || runnerReceipts.some(row => row.private || !this.nameable(canonicalJson(row.receipt)) || looksSecret(canonicalJson(row.receipt)));
       const status = this.d.board.experimentAttemptStatus(attempt.attemptId);
       const observations = page.rows.flatMap(row => row.observations), events = page.rows.map(row => row.event);
-      const evidence = projectExperimentWithObservations(record.protocol, events, observations);
+      const evidence = { ...projectExperimentWithObservations(record.protocol, events, observations),
+        ...(runnerReceipts.length ? { runnerAttested: runnerReceipts.map(row => ({ ...projectRunnerReceipt(record.protocol, row.receipt), key: { hash: row.keyHash, status: this.runnerKeyStatus(row) } })) } : {}) };
       views.push({ id: attempt.attemptId, protocolHash: record.hash, taskId: attempt.attempt.taskId, phase: attempt.attempt.phase, status, private: privateRecord,
         campaignRevision: record.protocol.campaignRevision, approval: this.experimentApproved(record) ? "approved" : "unapproved",
         postHoc: this.d.board.experimentProtocolContext(record.hash).state,
         ...(attempt.attempt.retryOf ? { retryOf: attempt.attempt.retryOf } : {}), ...(attempt.attempt.reproducesAttemptId ? { reproducesAttemptId: attempt.attempt.reproducesAttemptId } : {}), independentlyReproduced: false,
         protocol: { value: privateRecord ? "[pii]" : record.protocol, provenance: "declared" },
         events: page.rows.map(row => privateRecord ? { seq: row.event.seq, kind: row.event.kind, at: row.event.at, provenance: row.event.provenance, body: "[pii]" } : row.event),
-        evidence: privateRecord ? { declared: "[pii]", measured: evidence.measured.map(row => ({ eventSeq: row.eventSeq, source: row.source, provenance: "host-observed", values: "[pii]" })) } : evidence,
+        evidence: privateRecord ? { declared: "[pii]", measured: evidence.measured.map(row => ({ eventSeq: row.eventSeq, source: row.source, provenance: "host-observed", values: "[pii]" })), ...(runnerReceipts.length ? { runnerAttested: runnerReceipts.map(() => ({ provenance: "runner-attested", values: "[pii]" })) } : {}) } : evidence,
         eventsComplete: page.done, ...(!page.done ? { nextEventCursor: page.afterSeq } : {}) });
     }
     return { attempts: views, counts: { all: summary.total, statuses: summary.statuses }, ...(nextCursor === undefined ? {} : { nextCursor }) };
@@ -4862,7 +4911,7 @@ export class Tasks {
 
   /** The board as the merge queue and the guarded merge read it (#786): ids, dependencies, privacy, receipts, findings and plans. */
   private deliveryLinks(config: SdlcConfig): DeliveryTask[] {
-    return this.d.board.list().map(t => ({ id: t.id, after: t.deps ?? [], private: this.isPii(t), receipt: t.sdlc, phase: this.isPii(t) ? undefined : this.workflowView(t), findings: this.isPii(t) ? undefined : this.reviewFindingSets(t), plan: config.mode === "off" || this.isPii(t) ? undefined : { paths: this.planPaths(t), revision: t.history.findLast(h => h.planRevision)?.planRevision?.revision ?? 0, fingerprint: planFingerprint(t.plan ?? {}), accepted: this.validPlanDepartures(t) } }));
+    return this.d.board.list().map(t => ({ id: t.id, after: t.deps ?? [], private: this.isPii(t), latestHead: this.reviewHead(t), approval: approvalBinding(t), receipt: t.sdlc, phase: this.isPii(t) ? undefined : this.workflowView(t), findings: this.isPii(t) ? undefined : this.reviewFindingSets(t), plan: config.mode === "off" || this.isPii(t) ? undefined : { paths: this.planPaths(t), revision: t.history.findLast(h => h.planRevision)?.planRevision?.revision ?? 0, fingerprint: planFingerprint(t.plan ?? {}), accepted: this.validPlanDepartures(t) } }));
   }
 
   /**
@@ -4989,6 +5038,8 @@ export class Tasks {
   private mergeRecordCurrent(id:number,by:PeerId,record:MergeRecord,artifactCurrent:()=>boolean):Task|undefined {
     const now=this.d.board.get(id);
     return artifactCurrent() && now && now.sdlc?.repo===record.repo && now.sdlc.pr===record.pr && now.sdlc.reviewedHead===record.head
+      && (!approvalBinding(now) || approvalBinding(now)!.current && approvalBinding(now)!.head === record.head)
+      && (!this.reviewHead(now) || this.reviewHead(now) === record.head)
       && now.state==="approved" && !this.isPii(now) && !this.d.privateTurn?.(by) && this.mergeAuthority(by)
       && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError ? now : undefined;
   }
@@ -5629,7 +5680,7 @@ export class Tasks {
   isChecking = (id: number) => this.checking.has(id);
 
   /** Invalidate stale artifact evidence without changing spec acceptance or open findings. */
-  private completionDraft(task: Task, refresh?: CompletionRefresh): Task {
+  private completionDraft(task: Task, refresh?: Pick<CompletionRefresh, "commit">): Task {
     if (!refresh || !task.sdlc) return task;
     const sdlc = { ...task.sdlc };
     if (sdlc.head !== refresh.commit) { delete sdlc.head; delete sdlc.observed; }
@@ -5642,13 +5693,14 @@ export class Tasks {
   private completionCurrent(id: unknown, by: PeerId, preEffect: boolean, refresh?: CompletionRefresh): Task {
     const task = this.need(id, false, preEffect);
     this.mine(task, by, "owner", preEffect);
-    if (refresh && (task.state !== "in_review" || task.history.length !== refresh.revision))
+    if (refresh && (task.state !== refresh.state || task.history.length !== refresh.revision))
       throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: review changed during re-file; retry on current work`);
     if (preEffect) {
-      if (task.state === "in_review" && !refresh || isClosedTaskState(task.state)) throw new PreEffectToolRefusal(`task #${task.id} is already ${task.state}`);
+      if (task.state === "in_review" && !refresh || isClosedTaskState(task.state) && !(task.state === "approved" && refresh)) throw new PreEffectToolRefusal(`task #${task.id} is already ${task.state}`);
     } else {
-      if (task.state === "in_review" && !refresh || isClosedTaskState(task.state)) throw new Error(`task #${task.id} is already ${task.state}`);
+      if (task.state === "in_review" && !refresh || isClosedTaskState(task.state) && !(task.state === "approved" && refresh)) throw new Error(`task #${task.id} is already ${task.state}`);
     }
+    if (task.sdlc?.merge?.state === "merged") throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: PR is merged`);
     this.ready(task, preEffect);
     if (task.state === "proposed" || task.state === "changes_requested") this.acceptanceCapacity(task);
     if (this.checking.has(task.id)) {
@@ -5658,18 +5710,42 @@ export class Tasks {
     return this.completionDraft(task, refresh);
   }
 
+  /** An approval may reopen only while its linked PR is known not to be merged, even with lifecycle gates off. */
+  private async unmergedForReopen(task: Task, valid: () => Task): Promise<void> {
+    valid();
+    if (task.sdlc?.merge?.state === "merged") throw new PreEffectToolRefusal(`task #${task.id}: PR is merged`);
+    const { repo, pr } = task.sdlc ?? {};
+    if (!repo || !pr) return;
+    if (this.isPii(task)) throw new PreEffectToolRefusal(`task #${task.id}: PR merge state unavailable for private work`);
+    const original = this.need(task.id, false, true);
+    const identity = JSON.stringify([original.sdlc, original.refs, original.history.length]);
+    let state: unknown;
+    try {
+      const reply = await (this.d.sdlc?.gh ?? sdlcGh)(["pr", "view", String(pr), "--repo", repo, "--json", "state"]);
+      if (reply.code === 0) state = JSON.parse(reply.stdout).state;
+    } catch { /* unknown merge state refuses before effects */ }
+    valid();
+    const current = this.need(task.id, false, true);
+    if (JSON.stringify([current.sdlc, current.refs, current.history.length]) !== identity) throw new PreEffectToolRefusal(`task #${task.id}: task changed during merge-state read`);
+    if (state === "MERGED") throw new PreEffectToolRefusal(`task #${task.id}: PR is merged`);
+    if (state !== "OPEN" && state !== "CLOSED") throw new PreEffectToolRefusal(`task #${task.id}: PR merge state unavailable; cannot reopen approval`);
+  }
+
   async done(by: PeerId, id: unknown, summary?: string, refs?: TaskRefs, deliverables?: unknown): Promise<Task> {
     const requestCheck = this.requestCheck(by);
     const initial = this.need(id, false, true);
     this.mine(initial, by, "owner", true);
     let refresh: CompletionRefresh | undefined;
-    if (initial.state === "in_review") {
+    if (initial.state === "in_review" || initial.state === "approved") {
       const commit = cleanRefs(refs).commit;
       if (!commit || !/^[a-f0-9]{40}$/.test(commit) || commit === this.reviewHead(initial))
-        throw new PreEffectToolRefusal(`task #${initial.id} is already in_review; re-file requires a different full head SHA`);
-      refresh = { revision: initial.history.length, commit };
+        throw new PreEffectToolRefusal(`task #${initial.id} is already ${initial.state}; re-file requires a different full head SHA`);
+      refresh = { revision: initial.history.length, commit, state: initial.state };
     }
-    const valid = () => { requestCheck(); return this.completionCurrent(id, by, true, refresh); };
+    const submittedCommit = cleanRefs(refs).commit;
+    const draft = refresh ?? (submittedCommit && /^[a-f0-9]{40}$/.test(submittedCommit) ? { commit: submittedCommit } : undefined);
+    const valid = () => { requestCheck(); return this.completionDraft(this.completionCurrent(id, by, true, refresh), draft); };
+    if (initial.state === "approved") { await this.unmergedForReopen(initial, valid); valid(); }
     // #509a: a bad claim (a claimed hash, an outside or denied path, a missing file) is refused before any effect, with nothing recorded.
     const claims = deliverables === undefined ? undefined : this.deliverableClaims(deliverables, valid());
     // The PII screen reads the summary of a done that passes these checks (issue #198); they run again after it.
@@ -5691,7 +5767,7 @@ export class Tasks {
     task = current();
     let reviewEvidence: PrEvidence | undefined;
     if (this.d.sdlc && this.d.sdlc.config().mode !== "off") { reviewEvidence = await this.lifecycleGate(task, "review"); task = current(); }
-    const reviewAdmission = task.reviewer || this.d.prepareReviewBrief ? await this.reviewRequestAdmission(task, refs, true, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, refresh), link, refs), !task.reviewer) : undefined;
+    const reviewAdmission = task.reviewer || this.d.prepareReviewBrief ? await this.reviewRequestAdmission(task, refs, true, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, draft), link, refs), !task.reviewer) : undefined;
     task = current();
     // A member of a silent cohort (issue #107): its done is an intent, and the last of them integrates first.
     const cohort = this.cohorts.of(task.id);
@@ -5725,10 +5801,11 @@ export class Tasks {
     const command = this.d.runCheck ? this.d.check?.(task.class, task) : undefined;
     if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission, link, records, requestCheck, refresh);
     // The tool call returns now; a check can outlast an agent's tool timeout. The result decides what comes next.
+    if (refresh?.state === "approved") { await this.unmergedForReopen(task, valid); task = current(); }
     this.checking.set(task.id, task.owner);
     const checkedRefs = cleanRefs(refs);
     this.warmRepository({ ...task, refs: { ...task.refs, ...checkedRefs } });
-    const pending = this.d.board.update(task.id, by, "done (checking)", { ...(refresh ? { state: "in_progress" as const } : {}), codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...checkedRefs } }), refs: checkedRefs, ...(task.sdlc ? { sdlc: task.sdlc } : {}) }, summary, { withheld: withheld || undefined, ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    const pending = this.d.board.update(task.id, by, "done (checking)", { ...(refresh ? { state: "in_progress" as const } : {}), ...(refresh?.state === "approved" && !task.reviewer ? { reviewer: USER } : {}), codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...checkedRefs } }), refs: checkedRefs, ...(task.sdlc ? { sdlc: task.sdlc } : {}) }, summary, { withheld: withheld || undefined, ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
     if (refresh) { this.ciWatchers.cancel(pending.id); this.heldReviews.delete(pending.id); }
     this.releaseNotice(`task ${this.publicTitle(pending)} done by ${by}; its check is queued or running: ${command}`);
     const seen = { events: pending.history.length, owner: pending.owner };
@@ -5878,31 +5955,38 @@ export class Tasks {
     requestCheck();
     // A check's completion carries the records its `done (checking)` bound: the same bytes the owner delivered, not a later read.
     records ??= latestPendingDeliverables(task);
+    const submittedCommit = cleanRefs(refs).commit;
+    const draft = refresh ?? (submittedCommit && /^[a-f0-9]{40}$/.test(submittedCommit) ? { commit: submittedCommit } : undefined);
+    task = this.completionDraft(task, draft);
     let selection = this.poolReview(task, refs);
-    let reviewer = selection?.reviewer ?? task.reviewer, reviewEvidence: PrEvidence | undefined;
+    let reviewer = selection?.reviewer ?? task.reviewer ?? (refresh?.state === "approved" ? USER : undefined), reviewEvidence: PrEvidence | undefined;
     if (this.d.sdlc && this.d.sdlc.config().mode !== "off" && gated !== (reviewer ? "review" : "approval")) {
       reviewEvidence = await this.lifecycleGate(task, reviewer ? "review" : "approval");
       requestCheck();
-      task = this.withLink(this.completionCurrent(task.id, by, false, refresh), link, refs);
+      task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, false, refresh), draft), link, refs);
       selection = this.poolReview(task, refs);
-      reviewer = selection?.reviewer ?? task.reviewer;
+      reviewer = selection?.reviewer ?? task.reviewer ?? (refresh?.state === "approved" ? USER : undefined);
     }
     // A delayed local check needs a new readback; a completion-selected reviewer also needs optional facts in off mode.
     if (!admission && ((reviewer && (this.d.sdlc?.config().mode ?? "off") !== "off") || this.d.prepareReviewBrief)) {
-      admission = await this.reviewRequestAdmission(task, refs, false, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, refresh), link, refs), !reviewer);
+      admission = await this.reviewRequestAdmission(task, refs, false, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, draft), link, refs), !reviewer);
       requestCheck();
-      task = this.withLink(this.completionCurrent(task.id, by, false, refresh), link, refs);
+      task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, false, refresh), draft), link, refs);
     }
     selection = this.poolReview(task, refs);
-    reviewer = selection?.reviewer ?? task.reviewer;
+    reviewer = selection?.reviewer ?? task.reviewer ?? (refresh?.state === "approved" ? USER : undefined);
     const reviewCost: ReviewCost | undefined = reviewer && task.plan && (task.plan.review || task.plan.ci)
       ? { ...cleanCostPlan(task.plan), ...(admission?.ready && admission.head ? { head: admission.head } : {}) } : undefined;
     const routedSummary = selection?.reviewSelection?.blocked ? `${summary ?? ""}\nReview routing: ${this.assignmentNote("pool unavailable", selection)}`.trim() : summary;
+    if (refresh?.state === "approved") {
+      await this.unmergedForReopen(task, () => { requestCheck(); return this.completionCurrent(task.id, by, true, refresh); });
+      task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, true, refresh), draft), link, refs);
+    }
     const completedRefs = cleanRefs(refs);
     this.warmRepository({ ...task, refs: { ...task.refs, ...completedRefs } });
     const noWrites = this.noWritesRecorded({ ...task, refs: { ...task.refs, ...completedRefs } });
     const capacity = this.capacityBefore(task);
-    const next = this.d.board.update(task.id, by, "done", { codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...completedRefs } }), state: reviewer ? "in_review" : "approved", ...(selection ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection, { ...task, refs: { ...task.refs, ...completedRefs } }), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    const next = this.d.board.update(task.id, by, "done", { codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...completedRefs } }), state: reviewer ? "in_review" : "approved", ...(selection || refresh?.state === "approved" ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection, { ...task, refs: { ...task.refs, ...completedRefs } }), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
     this.queueReviewWritten(next);
     this.writePlannerNotices(next, capacity, next.state === "approved");
     this.ciWatchers.cancel(next.id); this.heldReviews.delete(next.id); // a newer head or a move ends the old head's watcher (#785 P1b)
@@ -6331,12 +6415,15 @@ export class Tasks {
 
   /** #520: the rendered review brief of a non-PII task's commit, or why there is none; empty without a commit. */
   briefText(task: Task): string {
-    if (this.isPii(task) || !task.refs.commit) return "";
+    if (this.isPii(task)) return "";
+    const approval = approvalText(approvalBinding(task));
+    const prefix = (brief: string) => [approval, brief].filter(Boolean).join("\n");
+    if (!task.refs.commit) return approval;
     try {
       const brief = this.d.reviewBrief?.(task);
-      if (!brief) return "";
-      return "unavailable" in brief ? `Review brief unavailable: ${brief.unavailable}.` : sanitize(renderReviewBrief(brief));
-    } catch { return "Review brief unavailable: it could not be built."; }
+      if (!brief) return approval;
+      return prefix("unavailable" in brief ? `Review brief unavailable: ${brief.unavailable}.` : sanitize(renderReviewBrief(brief)));
+    } catch { return prefix("Review brief unavailable: it could not be built."); }
   }
 
   async review(by: PeerId, id: unknown, verdict: unknown, note?: string, unmet?: unknown, head?: unknown, coverage?: unknown, findings?: unknown): Promise<Task> {
@@ -6348,17 +6435,21 @@ export class Tasks {
     let covered: { commit: string | undefined; receipt: string } | undefined;
     let conformanceIdentity: string | undefined;
     let reviewRound: number | undefined;
+    let withdrawalRevision: number | undefined;
+    const withdrawing = this.need(id, false, true).state === "approved" && verdict === "changes_requested";
     const valid = (): Task => {
       requestCheck();
       const refused = authority?.();
       if (refused) throw new PreEffectToolRefusal(refused); // rechecked after every await, right before each write
       const t = this.need(id, false, true);
+      if (withdrawalRevision !== undefined && t.history.length !== withdrawalRevision) throw new PreEffectToolRefusal(`task #${t.id}: approval changed during withdrawal`);
       if (reviewRound !== undefined && this.reviewRequestRevision(t) !== reviewRound) throw new PreEffectToolRefusal(`task #${t.id}: review request changed during the verdict; review the new head`);
       if (covered && (t.refs.commit !== covered.commit || JSON.stringify(t.sdlc ?? null) !== covered.receipt)) throw new PreEffectToolRefusal(`task #${t.id}'s commit or lifecycle receipt changed during the verdict: review the new head`);
       this.mine(t, by, "reviewer", true);
       if (verdict !== "approved" && verdict !== "changes_requested") throw new PreEffectToolRefusal('verdict must be "approved" or "changes_requested"');
-      if (t.state !== "in_review") throw new PreEffectToolRefusal(`task #${t.id} is ${t.state}: cannot move to ${verdict} before its owner calls hub_task_done`);
+      if (t.state !== (withdrawing ? "approved" : "in_review")) throw new PreEffectToolRefusal(`task #${t.id} is ${t.state}: cannot move to ${verdict} before its owner calls hub_task_done`);
       if (conformanceIdentity !== undefined && conformanceIdentity !== this.planIdentity(t)) throw new PreEffectToolRefusal("plan conformance identity changed during verdict");
+      if (t.sdlc?.merge?.state === "merged") throw new PreEffectToolRefusal(`task #${t.id}: PR is merged`);
       findingGuard?.(t);
       return t;
     };
@@ -6370,6 +6461,8 @@ export class Tasks {
     const mode = this.d.sdlc?.config().mode ?? "off";
     const initial = valid(), suppliedFindings = findings !== undefined;
     reviewRound = this.reviewRequestRevision(initial);
+    if (withdrawing) withdrawalRevision = initial.history.length;
+    if (withdrawing) { await this.unmergedForReopen(initial, valid); valid(); }
     let parsed: ReviewFinding[];
     try { parsed = parseReviewFindings(findings, { person: by === USER, maxNits: this.d.sdlc?.config().maxNits ?? DEFAULT_MAX_NITS }); }
     catch (error) { throw new PreEffectToolRefusal(error instanceof Error ? error.message : "invalid structured findings"); }
@@ -6474,6 +6567,7 @@ export class Tasks {
       task = valid();
       if (cleared && context === JSON.stringify({ title: task.title, detail: task.detail, refs: task.refs, plan: task.plan, signals: task.signals })) candidate = input; // Async screening cannot authorize a verdict under an obsolete role/state.
     }
+    if (withdrawing) { await this.unmergedForReopen(task, valid); task = valid(); }
     const pii = this.isPii(task);
     const reviewContext = by === USER ? undefined : this.d.reviewContext?.(by, task.id);
     const poolRequest = task.history.findLast(entry => ["done", "reviewer changed", "reviewer unavailable"].includes(entry.event));
@@ -6483,7 +6577,7 @@ export class Tasks {
     // #507b: unmet items that start with a recorded criterion id name that criterion. The ids come from the checklist on the board as it is at this
     // write (the `task` just rechecked by valid()), never from the caller; a PII task carries none, its checklist being private.
     const unmetCriteria = pii ? [] : unmetCriteriaIds(items, checklistOf(task.sdlc));
-    const flag = { ...this.planObservation(task), withheld: withheld || undefined, ...(report ? { reviewFindings: report } : {}), ...(unmetCriteria.length ? { unmetCriteria } : {}), ...(boundDeliverables ? { deliverables: boundDeliverables } : {}), ...(reviewContext ? { reviewContext } : {}), ...(codeScope ? { reviewScope: "code" as const } : {}), ...(evidenceOnly ? { evidenceOnly: true as const } : {}), ...(reviewerFamily ? { reviewerFamily } : {}), ...(reviewerReason ? { reviewerReason } : {}) };
+    const flag = { ...(findingHead ? { reviewedHead: findingHead } : {}), ...this.planObservation(task), withheld: withheld || undefined, ...(report ? { reviewFindings: report } : {}), ...(unmetCriteria.length ? { unmetCriteria } : {}), ...(boundDeliverables ? { deliverables: boundDeliverables } : {}), ...(reviewContext ? { reviewContext } : {}), ...(codeScope ? { reviewScope: "code" as const } : {}), ...(evidenceOnly ? { evidenceOnly: true as const } : {}), ...(reviewerFamily ? { reviewerFamily } : {}), ...(reviewerReason ? { reviewerReason } : {}) };
     if (verdict === "approved") {
       const capacity = this.capacityBefore(task);
       this.ciWatchers.cancel(task.id); this.heldReviews.delete(task.id);
@@ -6509,7 +6603,7 @@ export class Tasks {
       return next;
     }
     this.ciWatchers.cancel(task.id); this.heldReviews.delete(task.id);
-    const rejected = this.d.board.update(task.id, by, "changes_requested", { state: "changes_requested", rejections: evidenceOnly ? task.rejections : task.rejections + 1 }, note, flag);
+    const rejected = this.d.board.update(task.id, by, "changes_requested", { state: "changes_requested", rejections: evidenceOnly ? task.rejections : task.rejections + 1 }, note, flag, task.history.length);
     void this.mirrorVerdict(rejected, by, "changes_requested", reviewedHead ?? rejected.sdlc?.reviewedHead, note, withheld);
     if (!evidenceOnly) this.releaseNotice(`task #${rejected.id}: review saved but recurring-finding proposal unavailable`, () => this.proposeRecurringFindings(rejected, by, parsed, withheld));
     if (!evidenceOnly) this.releaseNotice(`task #${rejected.id}: review saved but recurring-criterion proposal unavailable`, () => this.proposeCriterionCandidates(rejected, by, withheld));
@@ -6522,6 +6616,11 @@ export class Tasks {
     if (!evidenceOnly) this.contradict(rejected);
     this.note(rejected, by, "decision", `Task #${rejected.id} changes requested by ${by}: ${rejected.title}\n${note ?? ""}`, withheld);
     if (evidenceOnly) this.tellConductorEvidenceOnly(rejected, by);
+    if (withdrawing) {
+      this.releaseNotice(`task ${this.publicTitle(rejected)}: could not tell its owner the approval was withdrawn`, () =>
+        this.tell(rejected, `Task #${rejected.id}: ${by} withdrew approval and requests changes. Review the findings, then call hub_task_done with the updated head.`, pii));
+      return rejected;
+    }
     if (!evidenceOnly && rejected.rejections >= (this.d.escalateAfter?.() ?? ESCALATE_AFTER)) {
       let moved: Task;
       try {

package/src/hub/usage-rollup.ts

@@ -1,6 +1,6 @@
-import { Database } from "bun:sqlite";
+import type { Database } from "./db-schema.ts";
+import { openHubDatabase } from "./db-schema.ts";
 import { closeSync, existsSync, fstatSync, openSync, readSync } from "node:fs";
-import { HUB_DB_BUSY_TIMEOUT_MS } from "./db-timeout.ts";
 
 /**
  * The usage roll-up (#683 U2): `events.jsonl` folded into `hub.db`, so a view never rescans the whole log.
@@ -77,8 +77,7 @@ export class UsageRollup {
   private closed = false;
 
   constructor(dbPath: string, private readonly eventsFile: string, private readonly opts: { maxBytesPerPass?: number } = {}) {
-    this.db = new Database(dbPath, { create: true });
-    this.db.run(`PRAGMA busy_timeout = ${HUB_DB_BUSY_TIMEOUT_MS}`);
+    this.db = openHubDatabase(dbPath, { create: true });
     const counters = KINDS.map(kind => `${kind} INTEGER NOT NULL DEFAULT 0, ${kind}_n INTEGER NOT NULL DEFAULT 0`).join(", ");
     this.db.run(`CREATE TABLE IF NOT EXISTS usage_rollup (day TEXT NOT NULL, peer TEXT NOT NULL, model TEXT NOT NULL, source TEXT NOT NULL, task INTEGER NOT NULL,
       pii INTEGER NOT NULL, records INTEGER NOT NULL DEFAULT 0, with_usage INTEGER NOT NULL DEFAULT 0, ${counters}, PRIMARY KEY (day, peer, model, source, task, pii))`);

package/src/pi/tool-receipts.ts

@@ -1,8 +1,8 @@
 import { chmodSync } from "node:fs";
-import { Database } from "bun:sqlite";
+import type { Database } from "../hub/db-schema.ts";
+import { openHubDatabase } from "../hub/db-schema.ts";
 import { createHash } from "node:crypto";
 import { PreEffectToolRefusal } from "../hub/tool-refusal.ts";
-import { HUB_DB_BUSY_TIMEOUT_MS } from "../hub/db-timeout.ts";
 
 export const PI_TOOL_RESULT_CAP = 100_000;
 /** Bound encoded text before wrapping it so escaping never cuts off trusted exit metadata. */
@@ -27,8 +27,7 @@ export class PiToolReceipts {
   private closed = false;
   private readonly pending = new Map<string, Promise<string>>();
   constructor(file: string) {
-    this.db = new Database(file, { create: true });
-    this.db.run(`PRAGMA busy_timeout = ${HUB_DB_BUSY_TIMEOUT_MS}`);
+    this.db = openHubDatabase(file, { create: true });
     chmodSync(file, 0o600);
     this.db.run(`CREATE TABLE IF NOT EXISTS pi_tool_receipts (
       session TEXT NOT NULL, call_id TEXT NOT NULL, fingerprint TEXT NOT NULL,