@staix/agent-hub 0.13.0 → 0.15.0

package/src/hub/tasks.ts

@@ -4,7 +4,8 @@ import { publicTestIntegrity, readTestIntegrity, testIntegrityBlockers, type Tes
 import { completePlanInventory, planConformance, planConformanceBlockers, planFingerprint, type PlanConformance } from "./plan-conformance.ts";
 import { RELEASE_TRAIN_HISTORY_LIMIT, releaseTrainData, releaseTrainReadiness, releaseMetrics } from "./sdlc-release.ts";
 import { cleanCostPlan, costMetrics, type CostPlan, type ReviewCost } from "./cost-governance.ts";
-import { specRefs } from "./spec-read.ts";
+import { qualifiedTitleRepos, siblingTitleRefs, specRefs } from "./spec-read.ts";
+import { sdlcMetrics, type BandResult, type MetricTask, type MetricsReport } from "./sdlc-metrics.ts";
 import type { InstancesConfig } from "./instances.ts";
 import { composeRememberText } from "./memory-fail.ts";
 import { VERSION } from "../version.ts";
@@ -20,7 +21,9 @@ import { correctionInput, resolveVisibleMemory } from "./memory-candidates.ts";
 import type { MemoryScreen } from "./read-tools.ts";
 import { withoutPii, mentionsPrivatePath } from "./memory-policy.ts";
 import { profileClass, profileData, profileTaskLabel, projectProfile, type ProfileName, type ProfileSelection, type ProjectProfile } from "./profiles.ts";
-import { criteriaView, workflowHash } from "./workflow.ts";
+import { criteriaView, unmetCriteriaIds, workflowHash } from "./workflow.ts";
+import { approvedDeliverables, latestDeliverables, parseDeliverableClaims, publicDeliverables, type DeliverableRecord, type DeliverableStatus } from "./deliverables.ts";
+import { checkDeliverables, DeliverableRefusal, hashDeliverables, vetDeliverables, type DeliverablePorts } from "./deliverable-files.ts";
 import { isAbsolute, relative } from "node:path";
 import type { Briefs, NativeItem } from "../memory/brief.ts";
 import type { MemoryClient } from "../memory/client.ts";
@@ -65,6 +68,13 @@ export interface TasksDeps {
   profile?: ProfileName;
   profileData?: ProjectProfile;
   piiPaths?: string[];
+  /** The project's secrets denylist (`local.deny`), for the deliverable file reader (#509a). */
+  deny?: string[];
+  /**
+   * #509a: the root a peer's files live under: its verified execution root (the daemon's `ownerWriteRoot`), which for a declared worktree
+   * instance is not the project checkout. `undefined` means the root is not proven right now. Absent (library use): the project root.
+   */
+  executionRoot?: (peer: PeerId) => string | undefined;
   catalog?: RoleCatalog;
   /** Role ids whose contract was prepared for the current native session. */
   sessionRoles?: (peer: PeerId) => string[];
@@ -91,6 +101,8 @@ export interface TasksDeps {
   reviewOnly?: (peer: PeerId) => boolean;
   /** #223: captured when a verdict call starts; a non-undefined result refuses the verdict at every later check. */
   reviewAuthority?: (by: PeerId, task: number) => (() => string | undefined) | undefined;
+  /** Host-captured current-child authority, rechecked before an admitted async tool first commits effects. */
+  requestAuthority?: (by: PeerId) => (() => string | undefined) | undefined;
   memory?: MemoryClient;
   /** Captured native profile fence at our memory operation boundaries; no board mutation. */
   memoryCheck?: () => void;
@@ -182,6 +194,11 @@ const OPEN: Task["state"][] = ["proposed", "in_progress", "changes_requested"];
 const QUIET_EVENTS = new Set(["answer", "reviewer changed", "idle sweep", "memory reference started"]);
 QUIET_EVENTS.add("ready held"); // #655: the hub's note that a ready task waits for its reserved owner's WIP slot.
 QUIET_EVENTS.add("plan observed"); // Host observation does not move the task or replace completion intent.
+/** The records of the `done (checking)` entry a passed check now completes: what the owner delivered then (#509a). */
+const latestPendingDeliverables = (task: Task): DeliverableRecord[] | undefined => {
+  const checking = task.history.findLastIndex(entry => entry.event === "done (checking)");
+  return checking >= 0 && !task.history.slice(checking + 1).some(entry => entry.event === "done") ? task.history[checking]!.deliverables : undefined;
+};
 
 /**
  * Thrown when an assignment's board write is saved but a publish or notify after it failed (#297): the move is
@@ -357,6 +374,12 @@ export class Tasks {
   };
 
   /** One bounded screen call. A screener that fails is no verdict, handled as PII (fail closed). */
+  private requestCheck(by: PeerId): () => void {
+    const authority = this.d.requestAuthority?.(by);
+    const check = () => { const reason = authority?.(); if (reason) throw new PreEffectToolRefusal(reason); };
+    check(); return check;
+  }
+
   private async screenCall(text: string): Promise<PiiVerdict> {
     return (await this.d.piiScreen?.(text).catch(() => undefined)) ?? { label: "unknown", miss: "failed", ms: 0 };
   }
@@ -558,6 +581,31 @@ export class Tasks {
   }
 
   /** Host-authored proposals contain only cleared IDs, integer task references and fixed instruction targets. */
+  /**
+   * #736: how many separate pieces of work the tasks are. Tasks that share a PR, a branch in one repository, or a
+   * supersession (a cancelled task names its replacement) are one piece of work, as an approve-as-step follow-up is: a
+   * finding carried between them is the same finding, not a recurrence.
+   */
+  private workUnits(rows: readonly Task[]): number {
+    const parent = new Map<number, number>();
+    const find = (id: number): number => { let at = id; while (parent.has(at)) at = parent.get(at)!; return at; };
+    const join = (a: number, b: number) => { const x = find(a), y = find(b); if (x !== y) parent.set(x, y); };
+    const first = new Map<string, number>(), ids = new Set(rows.map(row => row.id));
+    for (const row of rows) {
+      // Repository identity comes from the board's own resolver, so aliases match and an outside path never falls back to this project.
+      const prRepo = row.sdlc?.pr ? this.repositories.scope(row.sdlc.repo ? { repo: row.sdlc.repo, paths: row.refs.paths } : row.refs).key : "";
+      const branchRepo = row.refs.branch ? this.repositories.scope(row.refs).key : "";
+      for (const key of [prRepo ? `pr ${prRepo}#${row.sdlc!.pr}` : "", branchRepo ? `branch ${branchRepo} ${row.refs.branch}` : ""]) {
+        if (!key) continue;
+        const seen = first.get(key);
+        if (seen === undefined) first.set(key, row.id); else join(row.id, seen);
+      }
+      // superseded_by is free text ("task #73", "#73" or "73"); the first task number in it names the replacement.
+      const next = Number(/#?(\d+)/.exec(row.cancelled?.supersededBy ?? "")?.[1]);
+      if (ids.has(next)) join(row.id, next);
+    }
+    return new Set(rows.map(row => find(row.id))).size;
+  }
   private proposeRecurringFindings(task: Task, by: PeerId, items: readonly ReviewFinding[], withheld: boolean): void {
     if (withheld || this.isPii(task) || this.d.privateTurn?.(by) || !items.length || !this.findingTextAllowed(task, items)) return;
     const rows = this.d.board.list();
@@ -573,7 +621,7 @@ export class Tasks {
         const finding = last?.reviewFindings?.items.find(value => value.id === item.id);
         return !last?.withheld && finding && same(finding) && finding.disposition !== "false_positive" && this.findingTextAllowed(row, [finding]);
       });
-      if (new Set(holders.map(row => row.id)).size < 2) continue;
+      if (this.workUnits(holders) < 2) continue;
       const key = `Review finding key: ${item.pass}:${item.id}`;
       if (keys.has(key)) continue;
       const title = `Review policy amendment for recurring finding ${item.pass}:${item.id}`;
@@ -607,6 +655,8 @@ export class Tasks {
       ...(h.owner === undefined ? {} : { owner: h.owner }),
       ...(h.reviewerFamily ? { reviewerFamily: screenHistoryText(h.reviewerFamily, "reviewer family") } : {}),
       ...(h.reviewerReason ? { reviewerReason: h.reviewerReason } : {}),
+      ...(h.unmetCriteria?.length ? { unmetCriteria: h.unmetCriteria } : {}),
+      ...(h.deliverables?.length ? { deliverables: publicDeliverables(h.deliverables, this.nameable) } : {}),
       ...(h.reviewBlocked ? { reviewBlocked: true } : {}),
       ...(h.reviewerFailure ? { reviewerFailure: { peer: screenHistoryText(h.reviewerFailure.peer, "reviewer"), cause: h.reviewerFailure.cause, ...(h.reviewerFailure.head ? { head: screenHistoryText(h.reviewerFailure.head, "review head") } : {}) } } : {}),
       ...(h.planning ? { planning: { revision: h.planning.revision, fields: h.planning.fields, ...(h.planning.split ? { children: h.planning.split.children.map(child => child.id) } : {}) } } : {}),
@@ -744,10 +794,19 @@ export class Tasks {
   }
 
   /** What assignment weighs besides states and policy: quota, demotion and the review record. */
+  /**
+   * #525-3: the settled planner holders, sorted: the one input of the planner walk. It comes from the same settled role map as planner
+   * authority (`d.roles`), restricted to rostered peers, so assignment, planner notices and `route explain` agree on who the holders are.
+   * Read-only for now: the walk's result is shown and recorded nowhere until 525-2.
+   */
+  private plannerHolders(): PeerId[] {
+    return Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => Array.isArray(roles) && roles.includes("planner") && this.d.bus.isRostered(peer)).map(([peer]) => peer).sort();
+  }
+
   private weights(cls: TaskClass, task?: Task) {
     const now = Date.now();
     const quota = this.d.quota?.();
-    return { ...this.health(), ...(task ? { reviewPool: this.reviewPoolOptions(task) } : {}), now, demoted: this.demoted(cls, now), reviews: this.reviewRecord(cls), ...(quota ? { quota } : {}), ...(this.d.review?.adaptive ? { adaptive: { min: this.d.review.min_reviews } } : {}) };
+    return { ...this.health(), planners: this.plannerHolders(), ...(task ? { reviewPool: this.reviewPoolOptions(task) } : {}), now, demoted: this.demoted(cls, now), reviews: this.reviewRecord(cls), ...(quota ? { quota } : {}), ...(this.d.review?.adaptive ? { adaptive: { min: this.d.review.min_reviews } } : {}) };
   }
 
   /**
@@ -892,11 +951,11 @@ export class Tasks {
     }
     return parts.length ? `no peer can take the planner pull: ${parts.join("; ")}` : "no peer has eligible planner WIP capacity";
   }
-  private plannerAssignment(task: Task, reservedOnly = false): Assignment {
+  private plannerAssignment(task: Task, reservedOnly = false, routing: Routing = this.d.routing()): Assignment {
     const states = this.states();
     const full = this.plannerFull(task);
     // Preview the To Do transition without routing or offering the persisted backlog row.
-    return assign({ ...task, state: "proposed" }, states, this.d.routing(), { exclude: this.excluded(task), excludeOwners: full, ...(reservedOnly && task.reserved && !this.excluded(task).includes(task.reserved) ? { candidates: [task.reserved], namedOwner: task.reserved } : {}), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
+    return assign({ ...task, state: "proposed" }, states, routing, { exclude: this.excluded(task), excludeOwners: full, ...(reservedOnly && task.reserved ? { candidates: [task.reserved], namedOwner: task.reserved } : {}), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
   }
 
   async pullPlanned(by: PeerId, input: { id: number; revision: number; reason: string }): Promise<Task> {
@@ -921,14 +980,25 @@ export class Tasks {
           return !!competing && (competing.rank < order.rank || competing.rank === order.rank && competing.id < order.id);
         })) throw new PreEffectToolRefusal("a person's P0 backlog order is retained");
       }
-      const assignment = this.plannerAssignment(task);
-      if (!assignment.owner) throw new PreEffectToolRefusal(this.plannerRefusal(task));
-      if (this.hasPersonReservation(task) && assignment.owner !== task.reserved) throw new PreEffectToolRefusal("a person's reservation is retained");
+      if (task.reserved && this.excluded(task).includes(task.reserved)) throw new PreEffectToolRefusal(this.plannerRefusal(task));
+      const assignment = this.plannerAssignment(task, !!task.reserved);
+      if (!assignment.owner) {
+        const refusal = task.reserved ? `reserved peer ${task.reserved} cannot take the planner pull: ${assignment.refusals?.find(row => row.role === "owner" && row.peer === task.reserved)?.reason ?? "not eligible"}; ${this.plannerRefusal(task)}` : this.plannerRefusal(task);
+        throw new PreEffectToolRefusal(`${this.hasPersonReservation(task) ? "a person's reservation is retained; " : ""}${refusal}`);
+      }
       return { task, owner: assignment.owner };
     };
     const initial = validate(), withheld = await this.withholds("note", input.reason, initial.task);
     authorized();
     const current = validate();
+    if (current.task.reserved) {
+      return this.assignOwner(current.task, by, { candidates: [current.owner], namedOwner: current.owner, planner: true, refuseNamed: "pre",
+        plannerPull: { revision: input.revision, note: input.reason.trim(), withheld, guard: () => {
+          authorized();
+          const checked = validate();
+          if (checked.task.history.length !== current.task.history.length || checked.owner !== current.owner) throw new PreEffectToolRefusal("planner pull changed during admission");
+        } } });
+    }
     const pulled = this.d.board.pullPlanned(current.task.id, by, current.owner, input.revision, input.reason.trim(), withheld);
     this.planningRecorded({ by, task: pulled.id, fields: ["pull", "reserved"], revision: pulled.planningRevision! });
     return pulled;
@@ -1370,6 +1440,7 @@ export class Tasks {
   }
 
   async propose(by: PeerId, input: { title?: string; detail?: string; class?: string; role?: unknown; refs?: TaskRefs; plan?: TaskPlan; owner?: PeerId; after?: unknown; urgent?: unknown; backlog?: unknown; goal?: unknown }, external?: GitHubSource, created?: () => void): Promise<Task> {
+    const requestCheck = this.requestCheck(by);
     external = external ? { ...external } : undefined;
     if (external && (by !== USER || input.backlog !== true)) throw new PreEffectToolRefusal("external intake requires person-owned backlog staging");
     if (input.backlog !== undefined && typeof input.backlog !== "boolean") throw new PreEffectToolRefusal("backlog must be a boolean");
@@ -1414,6 +1485,7 @@ export class Tasks {
     // board, in no envelope and before no other model. A pattern match is PII without a call; no verdict is PII too.
     const screening = this.screenOn();
     const screened = screening && !signals.includes("pii") ? await this.screenCall(screenText({ ...text, detail: screenDetail, plan })) : undefined;
+    requestCheck();
     if (screened && screened.label !== "clear") signals.push("pii");
     let cls = baseGiven;
     let triaged = false;
@@ -1421,8 +1493,11 @@ export class Tasks {
     if (!cls && this.d.triage) {
       // Signals first: a PII task's text may only go to a model that is reached without leaving the campus network.
       const pii = this.isPii({ signals });
-      if (!pii || (await this.d.triage.onCampus().catch(() => false))) cls = await this.d.triage.classify(text.title, text.detail).catch(() => undefined);
+      const reached = !pii || await this.d.triage.onCampus().catch(() => false);
+      requestCheck();
+      if (reached) cls = await this.d.triage.classify(text.title, text.detail).catch(() => undefined);
       else fenced = true;
+      requestCheck();
       triaged = !!cls;
     }
     // A claim is work the caller will do itself: without a class and a model to name one, it is implementation (#6).
@@ -1438,11 +1513,13 @@ export class Tasks {
     if (reserved) this.requireCapabilities({ ...draft, signals, ...(external ? { external } : {}) }, reserved);
     this.warmRepository({ refs: draft.refs, plan });
     const repositoryMismatch = !this.isPii({ signals }) && this.repositories.mismatch(draft.refs, plan);
+    requestCheck();
     let task = this.d.board.propose(by, { ...draft, plan, ...(external ? { external } : {}), ...(deps.length ? { deps } : {}), ...(reserved ? { reserved } : {}), signals, ...(backlog ? { backlog: true } : {}) });
     if (repositoryMismatch) this.releaseNotice(`task #${task.id}: refs and plan name different repositories; check refs.repo before editing`);
     if (this.d.coordination) this.coordinationModes.set(task.id, this.d.coordination());
     created?.();
     if (screening) task = this.screenedTask(task, screened);
+    task = this.linkOnWrite(task); // #723
     if (goal) this.linkNative(task, goal, by);
     if (triaged) task = this.d.board.update(task.id, "hub", "triaged", {}, `class ${cls} named by the hub's model`);
     if (defaulted) task = this.d.board.update(task.id, "hub", "class defaulted", {}, "class implement for a claim without one");
@@ -1855,7 +1932,9 @@ export class Tasks {
       const task = this.d.board.get(target);
       if (!task) throw new Error(`no task #${target}`);
       if (isClosedTaskState(task.state)) return [...workflow, `task ${this.publicTitle(task)} (${task.state}): closed; not routed`];
-      const a = assign(task, this.states(), routing, { exclude: this.excluded(task), excludeOwners: this.plannerPullRecord(task)?.pull ? this.plannerFull(task) : [], waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
+      const planned = task.state === "backlog" && !!task.reserved || this.plannerPullRecord(task)?.pull === true;
+      const a = planned ? this.plannerAssignment(task, true, routing)
+        : assign(task, this.states(), routing, { exclude: this.excluded(task), waitsFor: this.waitsFor(task), ...this.weights(task.class, task) });
       // The split trace is for the pair the record is about: the task's owner when it has one (issue #109).
       return [...workflow, `task ${this.publicTitle(task)} (${task.state}, owner ${task.owner ?? "none"}${task.reserved ? `, reserved for ${task.reserved}` : ""})`, ...(task.profileClass ? [`profile class ${profileTaskLabel(task)}`] : []), ...(task.role ? [`task role ${task.role} (guidance only)`] : []), "if it were assigned now:", ...a.trace, ...(this.splitShadow(task, task.owner ?? a.owner)?.trace ?? [])];
     }
@@ -1943,14 +2022,17 @@ export class Tasks {
   }
 
   /** `override`: a person's explicit assign, which past refusals do not block and which drops an agent's reservation (#207). */
-  private async assignOwner(task: Task, by: PeerId, opts: { candidates?: PeerId[]; namedOwner?: PeerId; event?: string; note?: string; reason?: TaskMoveReason; clearOnFail?: boolean; exclude?: PeerId[]; context?: string; contextWithheld?: boolean; claim?: boolean; override?: boolean; roster?: boolean; planner?: boolean; expectedFlowRevision?: number; refuseNamed?: "pre" | "plain" } = {}): Promise<Task> {
-    if (task.state === "backlog") throw new PreEffectToolRefusal(`task #${task.id}: pull backlog work before assigning it`);
+  private async assignOwner(task: Task, by: PeerId, opts: { candidates?: PeerId[]; namedOwner?: PeerId; event?: string; note?: string; reason?: TaskMoveReason; clearOnFail?: boolean; exclude?: PeerId[]; context?: string; contextWithheld?: boolean; claim?: boolean; override?: boolean; roster?: boolean; planner?: boolean; expectedFlowRevision?: number; refuseNamed?: "pre" | "plain"; plannerPull?: { revision: number; note: string; withheld: boolean; guard: () => void } } = {}): Promise<Task> {
+    if (task.state === "backlog" && !opts.plannerPull) throw new PreEffectToolRefusal(`task #${task.id}: pull backlog work before assigning it`);
     const mode = (this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode;
     let stagedClaimGap: string | undefined;
     if (mode !== "off" && this.isBuildTask(task)) {
       const gap = task.sdlc?.planReview ? await this.planReviewGap(task) : "plan not reviewed since proposal";
       const current = this.d.board.get(task.id);
-      if (!current || !this.ownerAssignmentCurrent(task, current)) return current ?? task;
+      if (!current || !this.ownerAssignmentCurrent(task, current)) {
+        if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull changed during admission");
+        return current ?? task;
+      }
       task = current; // Reviewer-only and quiet bookkeeping updates do not supersede ownership authority.
       if (gap) {
         this.releaseNotice(`task ${this.publicTitle(current)}: ${gap}; planner: call hub_planner_groom then hub_plan_review`);
@@ -1967,9 +2049,10 @@ export class Tasks {
     const waits = this.waitsFor(task);
     const plannedMove = opts.planner || this.plannerPullRecord(task)?.pull === true && (by === HUB || opts.roster) && (opts.reason !== "manual" || opts.roster);
     const plannerFull = plannedMove ? this.plannerFull(task) : [];
-    const a = assign(task, this.states(), this.d.routing(), { exclude: [...(opts.override ? [] : this.excluded(task)), ...(opts.exclude ?? []), ...(opts.event === "escalated" && task.owner ? [task.owner] : [])], excludeOwners: plannerFull, ...(opts.candidates ? { candidates: opts.candidates } : {}), waitsFor: waits, ...this.weights(task.class, task), ...(opts.namedOwner ? { namedOwner: opts.namedOwner } : {}) });
+    const a = assign(opts.plannerPull ? { ...task, state: "proposed" } : task, this.states(), this.d.routing(), { exclude: [...(opts.override ? [] : this.excluded(task)), ...(opts.exclude ?? []), ...(opts.event === "escalated" && task.owner ? [task.owner] : [])], excludeOwners: plannerFull, ...(opts.candidates ? { candidates: opts.candidates } : {}), waitsFor: waits, ...this.weights(task.class, task), ...(opts.namedOwner ? { namedOwner: opts.namedOwner } : {}) });
 
     if (waits.length) {
+      if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull waits for dependency approval");
       this.releaseNotice(`task ${this.publicTitle(task)} waits for ${waits.map((id) => `#${id}`).join(", ")}; it is offered once they are approved`);
       return task;
     }
@@ -1995,7 +2078,13 @@ export class Tasks {
     // A person's explicit assign replaces an agent's reservation (#207). Only a refusal keeps the owner it moves away from
     // out for good: a reviewer's rejections or an escalation by hand, never the hub's own move after a failed delivery.
     const lasting = opts.event === "escalated" && task.owner && (opts.reason === "rejections" || opts.reason === "manual");
-    const next = this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.roster && task.state === "in_progress" ? { state: "proposed" as const } : {}), ...(opts.event === "escalated" ? { rejections: 0 } : {}), ...(opts.override && task.reserved ? { reserved: null } : {}) }, this.assignmentNote(`${opts.note ?? `to ${a.owner}`}${passed}`, a), { ...this.reviewMetadata(a), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}) }, opts.expectedFlowRevision);
+    opts.plannerPull?.guard();
+    const assignmentNote = this.assignmentNote(`${opts.note ?? `to ${a.owner}`}${passed}`, a);
+    const assignmentExtra = { ...this.reviewMetadata(a), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}) };
+    const next = opts.plannerPull
+      ? this.d.board.pullAssigned(task.id, by, a.owner, opts.plannerPull.revision, opts.plannerPull.note, opts.plannerPull.withheld, a.reviewer ?? null, assignmentNote, assignmentExtra, task.history.length)
+      : this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(opts.roster && task.state === "in_progress" ? { state: "proposed" as const } : {}), ...(opts.event === "escalated" ? { rejections: 0 } : {}), ...(opts.override && task.reserved ? { reserved: null } : {}) }, assignmentNote, assignmentExtra, opts.expectedFlowRevision);
+    if (opts.plannerPull) this.planningRecorded({ by, task: next.id, fields: ["pull", "reserved"], revision: next.planningRevision! });
     // What calibration reads (issue #109): routing chose the first owner (no single named candidate, no claim; not an
     // escalation, relay or reassignment of work already begun), and the work overlaps another owner's task not started
     // yet. For the record only. Work routed back to its proposer is left out, as its observations are (by === owner).
@@ -2009,6 +2098,11 @@ export class Tasks {
     // The cohort record formed just below reads it, and so does `route explain` while that turn lasts.
     if (opts.claim && a.owner === by && this.d.bus.peers.get(by)?.state === "busy") this.sent.set(handOver(next, by), by);
     try {
+      if (opts.plannerPull && task.offer) {
+        const prior = { ...task, owner: task.offer.owner };
+        this.withdrawRoleRequest(prior, next, "owner");
+        this.releaseNotice(`task #${next.id}: stale offer withdrawal failed`, () => this.d.bus.withdraw(task.offer!.envelopeId));
+      }
       if (by === USER && opts.event === "reassigned") this.withdrawRoleRequest(task, next, "owner");
       const hits = this.overlapHits(next);
       this.formCohort(next, hits);
@@ -2379,6 +2473,25 @@ export class Tasks {
     if (by !== USER && task[role] !== by) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: only its ${role} (${task[role] ?? "none"}) or the console user can do that`);
   }
 
+  /**
+   * #723: link the issue a task names the moment it is proposed or accepted, in advise and enforce, so the lifecycle never
+   * waits for a groom. It is a local parse with no GitHub read, and it never refuses or fails the write it follows.
+   */
+  private linkOnWrite(task: Task): Task {
+    try { return (this.d.sdlc?.config().mode ?? "off") === "off" ? task : this.linkIssue(task); }
+    catch { return task; }
+  }
+
+  /**
+   * #723: a title that qualifies another repository (`agent-mem#13`, `owner/repo#N`) while `refs.repo` is absent cannot link
+   * (the identity needs the repository), so the proposer is told to set it. Advice only; a PII task gets none.
+   */
+  refsRepoHint(task: Task): string | undefined {
+    if (this.isPii(task) || task.refs.repo || task.sdlc?.issue || (this.d.sdlc?.config().mode ?? "off") === "off") return undefined;
+    const names = qualifiedTitleRepos(task.title);
+    return names.length ? `task #${task.id}: the title names ${names.join(", ")}; set refs.repo to that repository (owner/name) so its issue links and the lifecycle shows it` : undefined;
+  }
+
   /** #694: write the one issue the task itself names (the plan-review source) into its lifecycle receipt, once; never relinks. */
   private linkIssue(task: Task): Task {
     if (this.isPii(task) || task.sdlc?.issue) return task;
@@ -2428,12 +2541,16 @@ export class Tasks {
     let issues: number[];
     try { issues = specRefs(task, repository); }
     catch { throw new PreEffectToolRefusal("plan review issue identity unavailable"); }
+    // #723: a title that qualifies the sibling repository `refs.repo` names (`agent-mem#13`) is a local parse, never a read.
+    // A sibling shorthand next to a bare #N is two identities, refused below, never the bare one alone.
+    issues = [...new Set([...issues, ...siblingTitleRefs(task.title, task.refs.repo)])];
     if (issues.length > 1) throw new PreEffectToolRefusal("plan review needs one explicit issue identity");
     return issues[0] ? { repo: repository, issue: issues[0] } : undefined;
   }
 
   async groomingDigest(by: PeerId): Promise<Record<string, unknown>> {
     this.planningAuthority(by);
+    this.backfillIssueLinks(by); // #723: first, bounded, before the slow reads
     const included = (task: Task) => !isClosedTaskState(task.state) || task.state === "cancelled" && task.history.some(entry => !!entry.supersededBy);
     const snapshot = this.d.board.list().filter(included), issues = new Map<string, PlanIssueMetadata>(), attempted = new Set<string>();
     const deadline = performance.now() + 4_000;
@@ -2473,17 +2590,114 @@ export class Tasks {
     const digest = plannerGrooming(visible, { repository: this.d.repository ?? `path:${realPath(this.d.cwd)}`,
       limits: Object.fromEntries(peers.map(peer => [peer, this.wipLimit(peer)])), wip: Object.fromEntries(peers.map(peer => [peer, this.wip(peer)])),
       states, issues, reviewedIssues, acceptedIssues, blockers });
-    // #694: backfill lifecycle issue links after every authority check, with their own bound (not the metadata-read
-    // budget): each call links up to 32 open tasks that still lack one, so later tasks are reached on later calls.
-    if ((this.d.sdlc?.config().mode ?? "off") !== "off") {
-      let linked = 0;
-      for (const task of this.d.board.list()) {
-        if (linked >= 32) break;
-        if (isClosedTaskState(task.state) || task.sdlc?.issue || this.isPii(task)) continue;
-        if (this.linkIssue(task) !== task) linked++;
+    return { ...digest, truncated: digest.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}) };
+  }
+
+  /**
+   * #694, #723: backfill lifecycle issue links with their own bounds, run first and apart from the slow metadata reads and
+   * the digest, so a groom that later times out has still linked. Each call links up to 32 open tasks that still lack one
+   * within a one-second budget, so later tasks are reached on later calls. A local parse; a failure skips that task only.
+   */
+  private backfillCursor = 0;
+  private backfillIssueLinks(by: PeerId): number {
+    if ((this.d.sdlc?.config().mode ?? "off") === "off") return 0;
+    // ponytail: 32 links and 1 s per call; raise both only with a measured groom time on a 400-task board.
+    const deadline = performance.now() + 1_000;
+    let linked = 0, i = 0;
+    const list = this.d.board.list(), n = list.length;
+    // The scan resumes where the last call stopped, so rows that never link cannot hold later ones back.
+    for (; i < n; i++) {
+      if (linked >= 32 || performance.now() >= deadline) break;
+      const task = list[(this.backfillCursor + i) % n]!;
+      if (isClosedTaskState(task.state) || task.sdlc?.issue || this.isPii(task)) continue;
+      this.planningAuthority(by);
+      try { if (this.linkIssue(task) !== task) linked++; } catch { /* one task never stops the rest */ }
+    }
+    this.backfillCursor = n ? (this.backfillCursor + i) % n : 0;
+    return linked;
+  }
+
+  /**
+   * #481 S7: the SDLC metrics from board history, read-only. Private tasks are counted as withheld and read for nothing else; PR
+   * readbacks are not made here (the cost report owns them), so merge time and same-head reruns read `unknown` unless given.
+   * Detection never calls a model and the report writes nothing.
+   */
+  sdlcMetrics(by: PeerId, since?: unknown, merged?: { mergedAt?: Record<number, number>; ciReruns?: Record<number, number | null> }): MetricsReport {
+    this.planningAuthority(by);
+    if (by !== USER && this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("metrics unavailable during private work");
+    let cutoff: number | undefined;
+    if (since !== undefined && since !== null && since !== "") {
+      cutoff = typeof since === "number" ? since : /^\d+$/.test(String(since)) ? Number(since) : Date.parse(String(since));
+      if (!Number.isFinite(cutoff) || cutoff < 0) throw new PreEffectToolRefusal("since must be a time (YYYY-MM-DD or an ISO timestamp) or milliseconds");
+    }
+    const rows = this.d.board.list();
+    const tasks: MetricTask[] = rows.map(task => ({ id: task.id, private: this.isPii(task), history: task.history.map(entry => ({ at: entry.at, event: entry.event,
+      ...(entry.reviewCost?.head ? { requestHead: entry.reviewCost.head } : {}), ...(entry.reviewFindings?.head ? { verdictHead: entry.reviewFindings.head } : {}) })) }));
+    const visibleIds = new Set(rows.filter(task => !this.isPii(task)).map(task => task.id));
+    const byKind: Record<string, number> = {};
+    for (const stall of this.stalled()) if (visibleIds.has(stall.task)) byKind[stall.cause.kind] = (byKind[stall.cause.kind] ?? 0) + 1;
+    const stalls = { open: Object.values(byKind).reduce((sum, n) => sum + n, 0), byKind, doneWithoutWrites: rows.filter(task => visibleIds.has(task.id) && task.history.findLast(entry => entry.event === "done")?.noWrites).length };
+    return sdlcMetrics(tasks, { ...(cutoff !== undefined ? { since: cutoff } : {}), ...(this.d.sdlc?.config().bands ? { bands: this.d.sdlc.config().bands } : {}), stalls, ...(merged ?? {}) });
+  }
+
+  /**
+   * #481 S7: act on the band tiers, deterministically and once per breach episode. An episode is a run of non-ok values for one metric
+   * (`BandResult.episode`, derived from history), so a sustained shift is one episode however many tasks finish inside it. `log` is one
+   * hub notice, `diagnose` one read-only `triage` backlog task and `propose` one `plan` backlog card naming the metric and its evidence.
+   * A metric with an open band card (a backlog or open task whose detail carries its key) writes nothing more, so a value that grows
+   * from diagnose to propose inside one episode does not add a second card. Held while the hub is stopping, recovering or has a
+   * storage error, like every host writer. The text is fixed words, numbers and task ids, never task text, and no GitHub issue is
+   * created. Returns the task ids created.
+   */
+  /**
+   * Whether `proposeFromBands` would run now, and a signature of what it would read. The daemon timer records a board revision only for a
+   * pass that ran, and re-runs when the signature changes (a reload that enables bands or edits them on an idle board).
+   */
+  bandsState(): { ready: boolean; signature: string } {
+    const config = this.d.sdlc?.config();
+    const configured = !!config && config.mode !== "off" && !!config.bands && Object.keys(config.bands).length > 0;
+    return { ready: configured && !this.d.sweepHeld?.() && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError, signature: configured ? JSON.stringify([config!.mode, config!.bands]) : "" };
+  }
+
+  proposeFromBands(by: PeerId = HUB): number[] {
+    const config = this.d.sdlc?.config();
+    if (!config || config.mode === "off" || !config.bands || !Object.keys(config.bands).length) return [];
+    if (this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) return [];
+    if (by !== HUB && by !== USER) this.planningAuthority(by);
+    const report = this.sdlcMetrics(by === HUB ? USER : by);
+    if (report.bands === "off") return [];
+    const rows = this.d.board.list();
+    const bandRows = rows.filter(row => row.history[0]?.by === HUB && row.detail?.startsWith("Band breach key: "));
+    const keyOf = (row: Task) => row.detail!.split("\n")[0]!.slice("Band breach key: ".length);
+    const seen = new Set(bandRows.map(keyOf));
+    // A card counts as open while its task is not closed: the planner has not yet decided on it.
+    const open = new Set(bandRows.filter(row => !isClosedTaskState(row.state)).map(row => keyOf(row).split(":")[0]!));
+    const created: number[] = [];
+    for (const band of report.bands as BandResult[]) {
+      if (band.tier === "ok" || band.lastTask === null || band.episode === null) continue;
+      const key = `${band.metric}:#${band.episode}`;
+      if (band.tier === "log") {
+        const marker = `${key}:log`;
+        if (!open.has(band.metric) && this.d.board.recordBandNotice(marker)) this.releaseNotice(`sdlc band: ${band.metric} is ${band.reason}; last value ${band.last} on task #${band.lastTask}`);
+        continue;
       }
+      if (seen.has(`${key}:propose`) || seen.has(`${key}:diagnose`) || open.has(band.metric)) continue;
+      const tier = band.tier === "propose" ? "propose" : "diagnose";
+      const full = `${key}:${tier}`;
+      const evidence = `metric ${band.metric}; newest value ${band.last} on task #${band.lastTask}; episode began at task #${band.episode}; baseline mean ${band.mean}, deviation ${band.sd} over ${band.baseline} tasks; ${band.reason}`;
+      const diagnose = tier === "diagnose";
+      const title = diagnose ? `Diagnose SDLC metric ${band.metric}: read-only triage` : `Review SDLC metric ${band.metric}: control band breach`;
+      const detail = `Band breach key: ${full}\n${evidence}\n${diagnose
+        ? "Read-only triage for the planner: inspect the recent task histories behind this metric and report what changed. Do not edit files, branches or the board."
+        : "Backlog card for the planner: decide whether this breach needs a process change. It names the metric and its evidence; it opens no GitHub issue."}`;
+      const draft = { title, detail, refs: {} };
+      const signals = this.signalsFor(draft);
+      if (this.isPii({ signals }) || !this.candidateTextAllowed(`${title}\n${detail}`)) continue;
+      const proposal = this.d.board.propose(HUB, { ...draft, class: diagnose ? "triage" : "plan", backlog: true, signals });
+      this.incomingBacklog.add(proposal.id); seen.add(full); open.add(band.metric); created.push(proposal.id);
     }
-    return { ...digest, truncated: digest.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}) };
+    for (const id of created) this.releaseNotice(`task #${id}: SDLC control band breach proposed in the backlog`);
+    return created;
   }
 
   /** S10 read-only planner report; S7 owns rolling bands and automatic board proposals. */
@@ -2591,7 +2805,23 @@ export class Tasks {
   }
 
   /** Artifact links and claimed local gates stay on the board; no outside text is accepted. */
-  recordLifecycle(by: PeerId, id: unknown, input: unknown): Task {
+  /**
+   * `hub_sdlc_record` (#509a): the receipt may also name `deliverables`. They are split off here, claims vetted and the files hashed by the hub,
+   * and only then is the rest recorded as before. A receipt with deliverables and nothing else records just the deliverables.
+   */
+  async recordSdlc(by: PeerId, id: unknown, input: unknown): Promise<Task> {
+    if (!input || typeof input !== "object" || Array.isArray(input) || !("deliverables" in input)) return this.recordLifecycle(by, id, input);
+    const { deliverables, ...receipt } = input as Record<string, unknown>;
+    const task = this.need(id, false, true);
+    if (by !== USER && by !== task.owner && by !== task.reviewer) throw new PreEffectToolRefusal("only the task owner, reviewer or console user may record lifecycle evidence");
+    const claims = this.deliverableClaims(deliverables, task);
+    const records = await this.hashClaims(claims, task, true);
+    const current = this.need(id, false, true);
+    if (current.history.length !== task.history.length) throw new PreEffectToolRefusal("task changed while its deliverables were hashed; record them again");
+    return this.recordLifecycle(by, id, receipt, records);
+  }
+
+  recordLifecycle(by: PeerId, id: unknown, input: unknown, deliverables?: DeliverableRecord[]): Task {
     const task = this.need(id, false, true);
     if (by !== USER && by !== task.owner && by !== task.reviewer) throw new PreEffectToolRefusal("only the task owner, reviewer or console user may record lifecycle evidence");
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
@@ -2621,7 +2851,7 @@ export class Tasks {
     if (next.reviewedHead !== undefined && (next.reviewedHead !== task.sdlc?.reviewedHead || (suppliedHead && artifactChanged))) this.mine(task, by, "reviewer", true);
     const departure = task.history.findLast(h => h.by === USER && h.planDeparture)?.planDeparture;
     const invalidatesDeparture = !!departure && (artifactChanged || next.localHead !== task.sdlc?.localHead && next.localHead !== undefined && next.localHead !== departure.head || next.reviewedHead !== task.sdlc?.reviewedHead && next.reviewedHead !== undefined && next.reviewedHead !== departure.head);
-    return this.d.board.update(task.id, by, "lifecycle", { sdlc: next }, undefined, { ...this.planObservation({ ...task, sdlc: next }), ...(invalidatesDeparture ? { planDepartureInvalidated: true } : {}) });
+    return this.d.board.update(task.id, by, "lifecycle", { sdlc: next }, undefined, { ...this.planObservation({ ...task, sdlc: next }), ...(invalidatesDeparture ? { planDepartureInvalidated: true } : {}), ...(deliverables ? { deliverables } : {}) });
   }
 
   async deliveryQueue(repo: string) {
@@ -2831,7 +3061,9 @@ export class Tasks {
     const task = this.need(id, false, true), config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
     if (config.mode === "off" || by === USER || !input || typeof input !== "object" || !("stage" in input)) return;
     let next: ReturnType<typeof sdlcReceipt>;
-    try { next = sdlcReceipt(input, task.sdlc, config, VERSION); } catch { return; } // recordLifecycle reports an invalid receipt
+    // #509a: `deliverables` ride in the receipt but are not a lifecycle field: recordSdlc splits them off, so the gate reads the same receipt it will record.
+    const { deliverables: _carried, ...lifecycleInput } = input as Record<string, unknown>;
+    try { next = sdlcReceipt(lifecycleInput, task.sdlc, config, VERSION); } catch { return; } // recordLifecycle reports an invalid receipt
     const definition = stageDefinition(config, next.stage);
     if (next.stage === task.sdlc?.stage || !definition || canonicalStage(definition.base) !== "build") return;
     const accepted = next.acceptance;
@@ -2909,6 +3141,7 @@ export class Tasks {
     return base === "build" || base === "implement";
   }
   async acceptReviewed(by: PeerId, id: unknown, plan?: unknown, refs?: unknown): Promise<Task> {
+    const requestCheck = this.requestCheck(by);
     const metadata = acceptRefs(refs);
     const task = this.need(id, false, true);
     this.mine(task, by, "owner", true);
@@ -2919,6 +3152,7 @@ export class Tasks {
     if ((this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode === "off" || !this.isBuildTask(task)) return this.accept(by, id, plan, metadata);
     await this.specGate(by, id);
     await this.planEntryGate(by, draft);
+    requestCheck();
     const current = this.need(id, false, true);
     this.mine(current, by, "owner", true);
     if (current.history.length !== task.history.length || current.owner !== task.owner) throw new PreEffectToolRefusal("task changed during build admission");
@@ -2997,7 +3231,7 @@ export class Tasks {
     this.warmRepository(draft);
     const repositoryChanged = this.repositories.scope(task.refs).key !== this.repositories.scope(draft.refs).key;
     const before = new Set(this.overlapHits(task).map((h) => h.task.id));
-    const next = this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) });
+    const next = this.linkOnWrite(this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) })); // #723: refs.repo may have just arrived
     this.captureOwnerAcceptance(next);
     this.d.notify(`task ${this.publicTitle(next)} accepted by ${by}`);
     if (repositoryChanged) this.cohorts.leave(next.id);
@@ -3075,6 +3309,59 @@ export class Tasks {
     return this.assignOwner(back, HUB, { event: "reassigned", reason: "declined", clearOnFail: true, ...(capacity === true && task.owner ? { exclude: [task.owner] } : {}), ...(planned ? { planner: true } : {}) });
   }
 
+  /**
+   * #509a: the task's deliverables as they are now against what was delivered and what was approved. `changedSinceReview` is true only for a file
+   * measured to differ from the bytes a reviewer approved (or, before approval, from the bytes delivered); a file the hub cannot read is
+   * `unknown`, never `unchanged`. Ids, hashes and sizes only for a private record. Undefined when the task delivered nothing.
+   */
+  async deliverableStatus(task: Task): Promise<{ state: "none" | "delivered" | "approved"; changedSinceReview: boolean; files: DeliverableStatus[] } | undefined> {
+    const delivered = latestDeliverables(task.history);
+    if (!delivered) return undefined;
+    const approved = task.state === "approved" ? approvedDeliverables(task.history) : undefined;
+    const basis = approved ?? delivered;
+    const checks = await this.checkRecords(basis, task);
+    const shown = publicDeliverables(basis, this.nameable)!;
+    const files = checks.map((check, i): DeliverableStatus => {
+      const { sha256, id, format, version, path, private: hidden } = shown[i]!;
+      return { id, sha256, state: check.state, ...(path ? { path } : {}), format, ...(version ? { version } : {}), ...(hidden ? { private: true as const } : {}) };
+    });
+    return { state: approved ? "approved" : "delivered", changedSinceReview: files.some(file => file.state === "changed"), files };
+  }
+
+  /** Check records against the owner's root; with that root unproven every file is `unknown` (never `unchanged`, never an exception). */
+  private async checkRecords(records: DeliverableRecord[], task: Task) {
+    try { return await checkDeliverables(records, this.deliverablePorts(task)); }
+    catch (error) { return records.map(record => ({ record, state: "unknown" as const, why: error instanceof Error ? error.message : "unreadable" })); }
+  }
+
+  /** What the deliverable reader needs from the host: the project root, the secrets denylist, and which files make a record private (#509a). */
+  private deliverablePorts(task: Task): DeliverablePorts {
+    const taskPrivate = this.isPii(task);
+    // The owner's own root: a declared worktree instance writes under its worktree, so its deliverables are hashed there, never in the canonical
+    // checkout (which holds a different file or none). With the root unproven there is nothing safe to hash: refuse rather than guess.
+    const root = !this.d.executionRoot || !task.owner || task.owner === USER ? this.d.cwd : this.d.executionRoot(task.owner);
+    if (root === undefined) throw new DeliverableRefusal(`deliverables: ${task.owner}'s execution root is not verified right now, so its files cannot be hashed`);
+    return { cwd: root, deny: this.d.deny ?? [], private: path => taskPrivate || matchesPolicy(root, path, this.d.piiPaths ?? [], true) };
+  }
+
+  /**
+   * #509a: parse and vet a call's deliverable claims before any effect. A claimed hash is a refusal (the hub hashes the files itself), and so is a
+   * path outside the project, on the denylist, inside the hub's own state, not a regular file, missing or too large. Nothing is hashed or stored here.
+   */
+  private deliverableClaims(input: unknown, task: Task, preEffect = true) {
+    try {
+      const claims = parseDeliverableClaims(input);
+      vetDeliverables(claims, this.deliverablePorts(task));
+      return claims;
+    } catch (error) { throw new (preEffect ? PreEffectToolRefusal : Error)(error instanceof Error ? error.message : "invalid deliverables"); }
+  }
+
+  /** Hash vetted claims now. A refusal during the read (the file changed while it was read) is still before any write. */
+  private async hashClaims(claims: ReturnType<Tasks["deliverableClaims"]>, task: Task, preEffect = true): Promise<DeliverableRecord[]> {
+    try { return await hashDeliverables(claims, this.deliverablePorts(task)); }
+    catch (error) { throw new (preEffect ? PreEffectToolRefusal : Error)(error instanceof DeliverableRefusal || error instanceof Error ? error.message : "deliverables could not be hashed"); }
+  }
+
   /** Tasks whose check is queued or running, and the owner it was started for. */
   private readonly checking = new Map<number, PeerId | null>();
   private checkQueue: Promise<void> = Promise.resolve();
@@ -3102,11 +3389,17 @@ export class Tasks {
     return task;
   }
 
-  async done(by: PeerId, id: unknown, summary?: string, refs?: TaskRefs): Promise<Task> {
-    const valid = () => this.completionCurrent(id, by, true);
+  async done(by: PeerId, id: unknown, summary?: string, refs?: TaskRefs, deliverables?: unknown): Promise<Task> {
+    const requestCheck = this.requestCheck(by);
+    const valid = () => { requestCheck(); return this.completionCurrent(id, by, true); };
+    // #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.
     const withheld = await this.withholds("summary", summary, valid());
     let task = valid();
+    // The hub hashes the files itself, once, here: what the owner delivered is what this read, whatever the file becomes afterwards.
+    const records = claims ? await this.hashClaims(claims, task, true) : undefined;
+    task = valid();
     // #481 S1: done without a separate accept starts build work too: the same live spec check as accept, before any write.
     if (task.state === "proposed" || task.state === "changes_requested") {
       const admission = task;
@@ -3152,12 +3445,12 @@ export class Tasks {
     }
     if (task.state === "proposed" || task.state === "changes_requested") task = this.withLink(this.d.board.update(task.id, by, "accepted", { state: "in_progress" }, WITH_DONE), link, refs); // done without a separate accept
     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);
+    if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission, link, records, requestCheck);
     // The tool call returns now; a check can outlast an agent's tool timeout. The result decides what comes next.
     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)", { codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...checkedRefs } }), refs: checkedRefs, ...(task.sdlc ? { sdlc: task.sdlc } : {}) }, summary, { withheld: withheld || undefined }, task.history.length, HOST_CODE_SYMBOLS);
+    const pending = this.d.board.update(task.id, by, "done (checking)", { 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);
     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 };
     this.pendingChecks++;
@@ -3288,11 +3581,15 @@ export class Tasks {
   }
 
   /** `gated`: the transition `done()` already gated with no await since, so it is not read back twice (#382). */
-  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review", admission?: ReviewReadiness, link?: IdentityLink): Promise<Task> {
+  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review", admission?: ReviewReadiness, link?: IdentityLink, records?: DeliverableRecord[], requestCheck: () => void = () => {}): Promise<Task> {
+    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);
     let selection = this.poolReview(task, refs);
     let reviewer = selection?.reviewer ?? task.reviewer, 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), link, refs);
       selection = this.poolReview(task, refs);
       reviewer = selection?.reviewer ?? task.reviewer;
@@ -3300,6 +3597,7 @@ export class Tasks {
     // 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(staged, link, refs), !reviewer);
+      requestCheck();
       task = this.withLink(this.completionCurrent(task.id, by, false), link, refs);
     }
     selection = this.poolReview(task, refs);
@@ -3310,7 +3608,7 @@ export class Tasks {
     const completedRefs = cleanRefs(refs);
     this.warmRepository({ ...task, refs: { ...task.refs, ...completedRefs } });
     const noWrites = this.noWritesRecorded({ ...task, refs: { ...task.refs, ...completedRefs } });
-    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), ...(reviewCost ? { reviewCost } : {}) }, 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 ? { 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), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
     this.cohorts.closed(next.id); // its owner's next native turn end settles it in its cohort (issue #107)
     this.note(next, by, "finding", `Task #${next.id} done by ${by}: ${next.title}\n${summary ?? ""}`, withheld);
     this.tellCompleted(next, summary, withheld);
@@ -3500,7 +3798,19 @@ export class Tasks {
     const checklistLines = checklistTemplates.map(template =>
       template.replaceAll("{target}", target).replaceAll("{check}", checkResult)
     );
-    const checklist = [
+    // #507b: the task's recorded acceptance criteria (the #481 S8 checklist, ids and all). A PII task shows none: its checklist is private.
+    const recorded = this.isPii(task) ? undefined : checklistOf(task.sdlc);
+    const criteriaBlock = recorded?.criteria.length
+      ? ["Acceptance criteria (name an id at the start of an unmet item, such as \"AC1: what is missing\"):",
+        ...recorded.criteria.map(c => `- ${c.id}${c.required ? "" : " (optional)"}: ${c.result}`)].join("\n") + "\n"
+      : "";
+    // #509a: what was delivered, by id, hash and size. A private record (a PII task, or a path under pii.paths) shows no path.
+    const delivered = publicDeliverables(latestDeliverables(task.history), this.nameable);
+    const deliverablesBlock = delivered?.length
+      ? ["Deliverables (the hub hashed these files when the task was done; approval binds these hashes):",
+        ...delivered.map(d => `- ${d.id}: ${d.path ?? "(path withheld)"} [${d.format}${d.version ? ` ${d.version}` : ""}] sha256 ${d.sha256.slice(0, 16)}, ${d.bytes} bytes`)].join("\n") + "\n"
+      : "";
+    const checklist = deliverablesBlock + criteriaBlock + [
       "Checklist:",
       ...this.planGuardItems(task).map(item => `- Check the plan against this live fail before the remaining checks: ${item.line}`),
       ...checklistLines.map(line => `- ${line}`),
@@ -3679,6 +3989,28 @@ export class Tasks {
       const checked = sdlcReceipt({ reviewedHead: head }, task.sdlc, this.d.sdlc?.config() ?? sdlcConfig(undefined));
       reviewedHead = checked.reviewedHead;
     }
+    // #509a: an approval binds the bytes that were delivered. The files are read again now: unchanged, their hashes go on the approval; changed,
+    // missing or unreadable, a reviewer's approval is refused before any write, and the person may approve the files as they are, saying so.
+    let boundDeliverables: DeliverableRecord[] | undefined;
+    if (verdict === "approved") {
+      const delivered = latestDeliverables(task.history);
+      if (delivered) {
+        const identity = JSON.stringify(delivered);
+        const checks = await this.checkRecords(delivered, task);
+        task = valid();
+        if (JSON.stringify(latestDeliverables(task.history)) !== identity) throw new PreEffectToolRefusal("the task's deliverables changed during the verdict; review the current work again");
+        const drift = checks.filter(check => check.state !== "unchanged");
+        if (!drift.length) boundDeliverables = delivered;
+        else {
+          const text = drift.map(check => `${check.record.id} (${check.state})`).join(", ");
+          if (by !== USER) throw new PreEffectToolRefusal(`deliverable changed since it was delivered: ${text}; ask its owner to call hub_task_done again so the current files are reviewed, or a person may approve them as they are`);
+          // The person approves what is on disk now: those bytes are measured and bound, and the verdict says the files had moved.
+          boundDeliverables = await this.hashClaims(delivered.map(record => ({ path: record.path!, format: record.format, ...(record.version !== undefined ? { version: record.version } : {}) })), task, true);
+          task = valid();
+          note = `${note ?? ""}\nApproved with the deliverable files changed since delivery: ${text}`.trim();
+        }
+      }
+    }
     if (verdict === "approved" && this.d.sdlc && this.d.sdlc.config().mode !== "off") { await this.lifecycleGate(task, "approval", reviewedHead, proposedSets(task)); task = valid(); }
     let candidate: Extract<CandidateInput, { kind: "fail" }> | undefined;
     if (verdict === "changes_requested" && items.length && this.d.candidates && !withheld && !this.isPii(task) && !this.d.privateTurn?.(by)) {
@@ -3697,7 +4029,10 @@ export class Tasks {
     const family = by === USER ? undefined : (this.d.adapterCatalog?.familyOf ?? familyOf)(by, this.d.instances?.());
     const reviewerFamily = poolRequest?.reviewerFamily === family ? family : undefined;
     const reviewerReason = reviewerFamily ? poolRequest?.reviewerReason : undefined;
-    const flag = { ...this.planObservation(task), withheld: withheld || undefined, ...(report ? { reviewFindings: report } : {}), ...(reviewContext ? { reviewContext } : {}), ...(reviewerFamily ? { reviewerFamily } : {}), ...(reviewerReason ? { reviewerReason } : {}) };
+    // #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 } : {}), ...(reviewerFamily ? { reviewerFamily } : {}), ...(reviewerReason ? { reviewerReason } : {}) };
     if (verdict === "approved") {
       const next = this.d.board.update(task.id, by, "approved", { state: "approved", rejections: 0, ...(reviewedHead && task.sdlc ? { sdlc: { ...task.sdlc, reviewedHead, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), "merge") } } : {}) }, note, flag);
       if (next.owner) {
@@ -3997,6 +4332,7 @@ export class Tasks {
   }
 
   async remember(by: PeerId, input: { text?: string; title?: string; kind?: string; task?: unknown; horizon?: unknown; scope?: unknown; approach?: unknown; symptom?: unknown; cause?: unknown; evidence?: unknown; retry_when?: unknown }): Promise<string> {
+    const requestCheck = this.requestCheck(by);
     const text = composeRememberText(input);
     const task = input.task !== undefined ? this.d.board.get(Number(input.task)) : undefined;
     if (task && this.isPii(task)) throw new Error("notes about a PII task are not saved: claude-mem processes what it stores with a cloud model");
@@ -4010,6 +4346,7 @@ export class Tasks {
     if (looksSecret(`${title}\n${text}`)) throw new Error("this note looks like it holds a secret (a key, token or password) and is not saved");
     if (this.aboutPrivatePath(title, text, task)) throw new Error("this note is about a path the project keeps private (pii.paths) and is not saved");
     if (await this.withholds("note", `${title}\n${text}`, task)) throw new Error("the PII screen did not clear this note, so it is not saved: claude-mem processes what it stores with a cloud model");
+    requestCheck();
     const kind = (NOTE_KINDS as readonly string[]).includes(String(input.kind)) ? String(input.kind) as Kind : "finding";
     const native = this.saveNative(by, kind, text, title, task, input.horizon === "long" || input.horizon === "short" ? input.horizon : undefined, input.scope === "shared" ? "shared" : "project");
     if (task && this.d.memory) this.markMemoryReference(task, by);