@staix/agent-hub 0.12.45 → 0.14.0

package/src/hub/tasks.ts

@@ -1,7 +1,11 @@
+import { buildTaskCodeSymbols, publicTaskCodeSymbols, taskCodeSymbolsDisjoint, HOST_CODE_SYMBOLS } from "./task-code-symbols.ts";
+import { normalizePlanSymbol, symbolsOverlap } from "./symbol-normalizer.ts";
+import { publicTestIntegrity, readTestIntegrity, testIntegrityBlockers, type TestIntegrity } from "./test-integrity.ts";
 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";
@@ -37,7 +41,7 @@ import { coverageGap, renderReviewBrief, type ReviewBrief } from "./review-brief
 import { definitionOf as builtinDefinitionOf } from "../adapters/registry.ts";
 import { ADAPTERS, DEFAULT_REVIEW_POOL, definitionOf, familyOf, type ProjectAdapterCatalog } from "../adapters/registry.ts";
 import { plannerGrooming, nextSweep, taskSweepConfig, type TaskSweepConfig, type SweepRecord } from "./task-sweep.ts";
-import { readPrCostHistory, readReviewReadiness, reviewReadinessFromEvidence, type PrEvidence, type ReviewReadiness, readPlanIssueMetadata, canonicalStage, checklistOf, readSdlcPr, readSpecEdit, sdlcConfig, sdlcReceipt, sdlcStatus, specState, SPEC_STATE_TEXT, stageDefinition, lifecycleStage, type SdlcConfig, type PlanIssueMetadata, sdlcGh, type SdlcGh, type SdlcStatus, type SpecEdit, type SpecState } from "./sdlc.ts";
+import { linkedReceipt, openPrFor, readPrCostHistory, readReviewReadiness, reviewReadinessFromEvidence, type PrEvidence, type ReviewReadiness, readPlanIssueMetadata, canonicalStage, checklistOf, readSdlcPr, readSpecEdit, sdlcConfig, sdlcReceipt, sdlcStatus, specState, SPEC_STATE_TEXT, stageDefinition, lifecycleStage, type SdlcConfig, type PlanIssueMetadata, sdlcGh, type SdlcGh, type SdlcStatus, type SpecEdit, type SpecState } from "./sdlc.ts";
 
 export type TaskAssignmentRole = "owner" | "reviewer";
 
@@ -72,6 +76,7 @@ export interface TasksDeps {
   /** Explicit acceptance/self-claim only; implicit done has no pre-work baseline. */
   ownerAccepted?: (task: Task) => void;
   /** #520: the review brief for a task's commit (git only, bounded); undefined when the task names no commit. */
+  prepareReviewBrief?: (task: Task) => Promise<void>;
   reviewBrief?: (task: Task) => ReviewBrief | { unavailable: string } | undefined;
   sdlc?: { config: () => SdlcConfig; gh?: SdlcGh };
   briefs?: Briefs;
@@ -176,6 +181,7 @@ const CONTRADICTION_WINDOW_MS = 7 * 86_400_000;
 const OPEN: Task["state"][] = ["proposed", "in_progress", "changes_requested"];
 /** Board events that leave a task where its completion check found it; any other event means it moved on meanwhile. */
 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.
 
 /**
@@ -277,6 +283,9 @@ const RESCREEN_MAX = 10;
  * The task flow. Adapters and tools never touch the board: every change comes through here, where assignment,
  * PII handling, envelopes, briefs and memory notes are decided in one place.
  */
+/** #694: a PR staged at done with the commit or branch it was read for. */
+interface IdentityLink { repo: string; pr: number; basis: { commit?: string; branch?: string } }
+
 export class Tasks {
   private readonly repositories: TaskRepositories;
   private readonly incomingBacklog = new Set<number>();
@@ -401,7 +410,7 @@ export class Tasks {
           } else {
             const admission = this.plannerPullRecord(task)?.pull ? this.plannerAssignment(task, true) : assign(task, this.states(), this.d.routing(), { exclude: this.excluded(task), ...this.weights(task.class, task) });
             this.releaseNotice(`${text} Owner reassignment suggestion: ${admission.owner ?? "no eligible peer"}.`);
-            if (admission.owner && config.auto_reassign && this.sweepAvailable(admission.owner)) {
+            if (admission.owner && config.auto_reassign && this.sweepAvailable(admission.owner) && !this.reservedHold(task)) {
               try { await this.assignOwner(this.d.board.get(task.id)!, HUB, { candidates: [admission.owner], event: "reassigned", reason: "idle", note: "ready-unassigned idle sweep" }); }
               catch (e) { if (!(e instanceof AssignmentUndeliveredError)) throw e; }
             }
@@ -582,9 +591,12 @@ export class Tasks {
   /** A task as a cloud peer may see it. */
 
   publicView(task: Task, fullHistory = false): Record<string, unknown> {
-    const { title, detail, history, external, cancelled, ...taskRest } = task;
+    const { title, detail, history, external, cancelled, codeSymbols, ...taskRest } = task;
     const rest = { ...taskRest, ...(history.some(h => h.by === USER && h.planDeparture) ? { planDepartureAccepted: true } : {}) };
     if (this.isPii(task)) return { ...rest, actualDates: actualTaskDates(task), refs: {}, plan: {}, ...(task.sdlc ? { sdlc: { stage: stageDefinition(this.d.sdlc?.config() ?? sdlcConfig(undefined), task.sdlc.stage)?.base ?? "unknown" } } : {}), title: "[pii]", detail: "[pii]" };
+    if (rest.sdlc?.redFirst && !this.publicMetadataText(JSON.stringify(rest.sdlc.redFirst))) {
+      const { redFirst: _withheld, ...receipt } = rest.sdlc; rest.sdlc = receipt;
+    }
     const screenHistoryText = (text: string, field: string, withheld = false): string => !withheld && this.nameable(text) ? text : `[history ${field} withheld: ${this.whyWithheld(text)}; ahub task show ${task.id}]`;
     const publicHistory = (fullHistory ? history : history.slice(-5)).map(h => ({
       at: h.at, by: h.by, event: h.event,
@@ -603,7 +615,9 @@ export class Tasks {
       ...(h.sweep ? { sweep: { kind: h.sweep.kind, activity: h.sweep.activity, step: h.sweep.step, at: h.sweep.at } } : {}),
     }));
     const sets = this.reviewFindingSets(task), current = findingsForHead(sets, this.findingHead(task));
-    return { ...rest, ...(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 };
+    const symbolRepository = codeSymbols && this.codeSymbolsRepository(task);
+    const publicSymbols = codeSymbols && symbolRepository ? publicTaskCodeSymbols(codeSymbols, this.reviewHead(task), symbolRepository.key, this.publicMetadataText) : undefined;
+    return { ...rest, ...(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. */
@@ -819,7 +833,7 @@ export class Tasks {
       // were stored as written, so both sides are compared in one spelling.
       if (mine.repositoryKey !== theirs.repositoryKey) continue;
       const file = (p: string) => normPath(p) !== "." && theirs.paths.some((q) => normPath(q) === normPath(p));
-      const same = mine.paths.some(file) || mine.symbols.some((x) => theirs.symbols.includes(x));
+      const same = mine.paths.some(file) || mine.symbols.some((x) => theirs.symbols.some((y) => symbolsOverlap(x, y)));
       if (!same || this.d.board.reviews({ task: t.id }).some((r) => r.kind === "contradicted")) continue;
       this.d.board.recordReview({ implementer: t.owner, reviewer: approval.by, class: t.class, kind: "contradicted", task: t.id });
     }
@@ -879,11 +893,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> {
@@ -908,14 +922,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;
@@ -1430,6 +1455,7 @@ export class Tasks {
     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");
@@ -1479,6 +1505,7 @@ export class Tasks {
     this.withdrawRoleRequest(confirmed, returned, "reviewer");
     this.incomingBacklog.add(confirmed.id);
     this.planningRecorded({ by, task: confirmed.id, fields: ["return"], revision: confirmed.planningRevision ?? 0 });
+    await this.releaseHeld(confirmed.owner); // its owner's slot is free (#655)
     return returned;
   }
 
@@ -1606,6 +1633,18 @@ export class Tasks {
   /** The tasks an overlap text for `task` names: their plans are in it (issue #108). */
   overlapTasks = (task: Task): number[] => this.overlapHits(task).map((h) => h.task.id);
 
+  /** Console detail advice only: no pair persistence, and no private task on either side. */
+  symbolOverlaps(task: Task): { task: number; files: string[]; sameFileDifferentSymbols: boolean }[] {
+    // A routing-locality opt-out does not make symbol metadata for a marked task public.
+    const markedPrivate = (value: Task) => value.signals.includes("pii") || value.signals.includes("pii_path");
+    if (markedPrivate(task)) return [];
+    return this.overlapHits(task).filter(hit => !markedPrivate(hit.task)).map(hit => ({
+      task: hit.task.id,
+      files: hit.paths.filter(this.publicMetadataText),
+      sameFileDifferentSymbols: this.sameFileDifferentSymbols(task, hit),
+    }));
+  }
+
   /**
    * Dashboard warning links (#264): the board's overlap pairs and the live cohorts, as task and peer ids only.
    * Paths, symbols and plans stay out; PII tasks are excluded by the same rules overlapHits applies.
@@ -1648,12 +1687,23 @@ export class Tasks {
    * ponytail: kept in memory, so after a restart such a notice is delivered whatever its task's state; persist the
    * condition if stale notices after restarts show up.
    */
-  private readonly conditional = new Map<string, { peer: PeerId; task: number; states: Task["state"][] }>();
+  private readonly conditional = new Map<string, { peer: PeerId; task: number; tasks?: number[]; states: Task["state"][] }>();
 
   /**
    * Publish a notice about `task`, which only matters to `to` while that task is in one of `states` for it (issue
    * #106): open work by default; the conflict notices of #91 count a task in review too.
    */
+  /**
+   * #713: the completed-change notice of task `done` for one recipient, about all of its tasks in `about`. It stays relevant while any of them is still open for the
+   * recipient, and carries `completedFor` so the bus replaces an earlier queued notice for the same `done` task and recipient.
+   */
+  whileOpenFor(to: PeerId, done: number, about: number[], body: string): void {
+    const env = newEnvelope(HUB, body, { to: [to], kind: "task", refs: { task: String(about[0]), taskRecipient: "owner", completedFor: done } });
+    this.conditional.set(env.id, { peer: to, task: about[0]!, tasks: about, states: OPEN });
+    if (this.conditional.size > 1024) this.conditional.delete(this.conditional.keys().next().value as string);
+    this.d.bus.publish(env);
+  }
+
   whileOpen(to: PeerId, task: number, body: string, states: Task["state"][] = OPEN): void {
     const env = newEnvelope(HUB, body, { to: [to], kind: "task", refs: { task: String(task), taskRecipient: "owner" } });
     this.conditional.set(env.id, { peer: to, task, states });
@@ -1682,8 +1732,8 @@ export class Tasks {
     }
     const c = this.conditional.get(env.id);
     if (!c || c.peer !== peer) return true;
-    const t = this.d.board.get(c.task);
-    return !!t && t.owner === peer && c.states.includes(t.state);
+    // A notice about several of the recipient's tasks matters while any one of them is still open for it (#713).
+    return (c.tasks ?? [c.task]).some((id) => { const t = this.d.board.get(id); return !!t && t.owner === peer && c.states.includes(t.state); });
   };
 
   /** Whether a model-written name may be shown to other peers and in the log: one matching a PII pattern may be PII. */
@@ -1719,7 +1769,12 @@ export class Tasks {
   private places(task: Task): { repositoryKey: string; paths: string[]; symbols: string[] } {
     const scope = this.repositories.scope(task.refs);
     const paths = [...(task.refs.paths ?? []), ...(task.plan?.paths ?? [])].map((p) => scope === this.repositories.project ? this.projectPath(p) : normPath(this.repositories.relativePath(scope, p)));
-    return { repositoryKey: scope.key, paths: [...new Set(paths)], symbols: [...(task.plan?.symbols ?? []), ...(task.plan?.sections ?? []).map(v => `section ${v}`), ...(task.plan?.sources ?? []).map(v => `source ${v}`)] };
+    const symbols = [
+      ...(task.plan?.symbols ?? []).map(normalizePlanSymbol),
+      ...(task.plan?.sections ?? []).map(v => `section ${v}`),
+      ...(task.plan?.sources ?? []).map(v => `source ${v}`),
+    ];
+    return { repositoryKey: scope.key, paths: [...new Set(paths)], symbols: [...new Set(symbols)] };
   }
 
   private roots?: string[];
@@ -1745,7 +1800,7 @@ export class Tasks {
       const theirs = this.places(t);
       if (mine.repositoryKey !== theirs.repositoryKey) return [];
       const paths = task.profile && t.profile && (task.plan?.sections?.length && t.plan?.sections?.length) ? [] : mine.paths.filter((p) => theirs.paths.some((q) => samePlace(p, q)));
-      const symbols = mine.symbols.filter((x) => theirs.symbols.includes(x));
+      const symbols = mine.symbols.filter((x) => theirs.symbols.some((y) => symbolsOverlap(x, y)));
       return paths.length || symbols.length ? [{ task: t, paths, symbols }] : [];
     });
   }
@@ -1813,7 +1868,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 ?? [])];
     }
@@ -1901,14 +1958,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`);
@@ -1925,9 +1985,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;
     }
@@ -1953,7 +2014,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).
@@ -1967,6 +2034,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);
@@ -2095,13 +2167,49 @@ export class Tasks {
     if (waits.length) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id} waits for ${waits.map((id) => `#${id}`).join(", ")}, not approved yet`);
   }
 
+  /** Ready offers between their cap check and the owner write (#655): task id -> reserved owner whose slot it takes. */
+  private readonly readyInFlight = new Map<number, PeerId>();
+
+  /** Offer order for ready work (#655): priority (urgent is P0, none is P2), then rank, then id. */
+  private readonly readyOrder = (a: Task, b: Task): number =>
+    (a.priority ?? (a.signals.includes("urgent") ? 0 : 2)) - (b.priority ?? (b.signals.includes("urgent") ? 0 : 2))
+    || (a.rank ?? Number.MAX_SAFE_INTEGER) - (b.rank ?? Number.MAX_SAFE_INTEGER) || a.id - b.id;
+
+  /** Ready work the hub parked on its reserved owner's WIP cap (#655): its latest move-or-hold entry is `ready held`. */
+  private isHeld(task: Task): boolean {
+    // A planner's priority or rank edit (`planned`) is no move: it must not make held work look released.
+    return task.history.findLast(entry => entry.event === "ready held" || !QUIET_EVENTS.has(entry.event) && entry.event !== "planned")?.event === "ready held";
+  }
+
+  /**
+   * Why readiness must not hand `task` to its reserved owner yet (#655): that owner is at its planner WIP cap, the count
+   * `acceptanceCapacity` refuses at. Peer id and counts only, so it is safe for a PII task. A reserved owner the task
+   * excludes is not honoured by routing, and planner-pulled work was admitted by its pull: neither is held.
+   */
+  private reservedHold(task: Task): string | undefined {
+    const owner = task.reserved;
+    if (!owner || task.owner || this.plannerPullRecord(task)?.pull === true || this.excluded(task).includes(owner)) return undefined;
+    // Offers in flight take a slot before their owner is written; once it is written wip() counts it, so never twice.
+    const flying = [...this.readyInFlight].filter(([id, peer]) => peer === owner && id !== task.id && !this.d.board.get(id)?.owner).length;
+    const limit = this.wipLimit(owner), used = this.wip(owner, task.id) + (this.pendingClaims.get(owner) ?? 0) + flying;
+    return used >= limit ? `reserved owner ${owner} is at its planner WIP cap (${used}/${limit}); stays ready in To Do with its reservation until a slot frees` : undefined;
+  }
+
+  /** The task is ready but its reserved owner has no room: say so once on the task history, never assign. */
+  private holdReady(task: Task, why: string, reason: string): void {
+    if (this.isHeld(task)) return;
+    const ready = task.history.at(-1)?.event === "ready" ? task : this.d.board.update(task.id, HUB, "ready", {}, why);
+    this.d.board.update(ready.id, HUB, "ready held", {}, reason);
+    this.releaseNotice(`task ${this.publicTitle(ready)} is ready but held: ${reason}`);
+  }
+
   /** An approved task may be the last thing others waited for: those go through assignment now (issue #34). */
   private async releaseDependents(approved: Task): Promise<void> {
     try {
-      for (const t of this.d.board.list("proposed")) {
-        if (!t.deps?.includes(approved.id) || t.owner || this.waitsFor(t).length) continue;
-        await this.offerReady(t, `#${approved.id} approved`);
-      }
+      // Its dependents and, as its owner's slot just freed (#655), that owner's held ready tasks: one list in priority order.
+      const ready = this.d.board.list("proposed").filter(t => !t.owner && !this.waitsFor(t).length
+        && (t.deps?.includes(approved.id) || !!approved.owner && t.reserved === approved.owner && this.isHeld(t))).sort(this.readyOrder);
+      for (const t of ready) await this.offerReady(t, t.deps?.includes(approved.id) ? `#${approved.id} approved` : "owner slot freed");
     } catch (e) {
       this.releaseNotice(`task #${approved.id}: could not release dependents: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -2223,14 +2331,25 @@ export class Tasks {
     this.offered.delete(task.id);
     this.releaseNotice(`task #${task.id}: cancellation stall cleanup unavailable`, () => this.d.board.clearStall(task.id));
     for (const peer of new Set([task.owner, task.reviewer])) if (peer && peer !== USER) this.releaseNotice(`task #${task.id}: cancellation notice unavailable`, () => this.d.bus.publish(newEnvelope(HUB, sanitize(`Task #${task.id} cancelled. Stop working on it. No native turn or working tree was changed.`), { to: [peer], kind: "task", priority: "important", refs: { task: String(task.id), taskCancelled: cancelled.flowRevision }, ...(this.isPii(next) ? { private: true } : {}) })));
+    await this.releaseHeld(task.owner); // its owner's slot is free (#655)
     this.releaseNotice(`task #${task.id}: cancellation dependent advice unavailable`, () => {
       for (const dependent of this.d.board.list()) if (!isClosedTaskState(dependent.state) && !dependent.owner && dependent.deps?.includes(task.id)) this.releaseNotice(`task #${dependent.id}: cancellation stall advice unavailable`, () => this.reportStall(dependent, { kind: "cancelled-dependency", dependency: task.id, code: "cancelled" }));
     });
     return next;
   }
 
+  /** A slot freed for `peer` (cancel, untouched return): its held ready tasks are offered in priority order, and the cap stops the offers (#655). */
+  private async releaseHeld(peer: PeerId | null | undefined): Promise<void> {
+    if (!peer) return;
+    try {
+      for (const t of this.d.board.list("proposed").filter(t => !t.owner && t.reserved === peer && this.isHeld(t) && !this.waitsFor(t).length).sort(this.readyOrder)) await this.offerReady(t, "owner slot freed");
+    } catch (e) {
+      this.releaseNotice(`task ${peer}: could not offer held ready work: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
   async releaseReady(): Promise<void> {
-    for (const t of this.d.board.list("proposed")) {
+    for (const t of [...this.d.board.list("proposed")].sort(this.readyOrder)) {
       if (t.owner) { this.d.board.clearStall(t.id); continue; }
       const cancelledDependency = t.deps?.find(id => this.d.board.get(id)?.state === "cancelled");
       if (cancelledDependency) { this.reportStall(t, { kind: "cancelled-dependency", dependency: cancelledDependency, code: "cancelled" }); continue; }
@@ -2242,7 +2361,7 @@ export class Tasks {
         continue;
       }
       this.d.board.clearStall(t.id);
-      if ((!t.deps?.length && !t.history.some(h => h.event === "backlog pulled")) || (!planned && last !== "blocked" && last !== "ready" && last !== "reserved")) continue;
+      if ((!t.deps?.length && !t.history.some(h => h.event === "backlog pulled")) || (!planned && last !== "blocked" && last !== "ready" && last !== "reserved" && !this.isHeld(t))) continue;
       // ponytail: a reserved owner (#207) that attaches after another peer that can take the task is passed over here like
       // an offline one; hold reserved tasks for a grace period if restarts show that up.
       await this.offerReady(t, "nothing left to wait for");
@@ -2251,13 +2370,18 @@ export class Tasks {
 
   /** Callers hold a list read before an await: re-read, or a task the other caller offered meanwhile is offered twice. */
   private async offerReady(stale: Task, why: string): Promise<void> {
-    let offering = false, undelivered: AssignmentUndeliveredError | undefined;
+    let offering = false, undelivered: AssignmentUndeliveredError | undefined, slot: PeerId | undefined;
     try {
       const t = this.d.board.get(stale.id);
       if (!t || t.state !== "proposed" || t.owner || this.personUnassigned(t) || this.offered.has(t.id)) return;
       const planned = this.plannerPullRecord(t)?.pull === true;
       const selected = planned ? this.plannerAssignment(t, true).owner : undefined;
       if (planned && !selected) return;
+      const held = planned ? undefined : this.reservedHold(t); // #655: the cap holds before the ready move is offered
+      if (held) { this.holdReady(t, why, held); return; }
+      // The check and the slot are one synchronous step: assignOwner can yield before it writes the owner, and a second offer
+      // for the same reserved owner must see this one as taking the last slot.
+      if (!planned && t.reserved) { slot = t.reserved; this.readyInFlight.set(t.id, slot); }
       this.offered.add(t.id);
       offering = true;
       const ready = t.history.at(-1)?.event === "ready" ? t : this.d.board.update(t.id, HUB, "ready", {}, why);
@@ -2269,6 +2393,7 @@ export class Tasks {
       if (e instanceof AssignmentUndeliveredError) undelivered = e;
       else this.releaseNotice(`task ${this.publicTitle(stale)}: could not be assigned: ${e instanceof Error ? e.message : String(e)}`);
     } finally {
+      if (slot) this.readyInFlight.delete(stale.id);
       if (offering && !undelivered) {
         try {
           if (!this.d.board.get(stale.id)?.owner) this.offered.delete(stale.id);
@@ -2284,6 +2409,67 @@ 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;
+    let identity: { repo: string; issue: number } | undefined;
+    try { identity = this.planIssueIdentity(task); } catch { return task; }
+    const next = identity && linkedReceipt(task.sdlc, identity, this.d.sdlc?.config() ?? sdlcConfig(undefined));
+    return next ? this.d.board.update(task.id, HUB, "lifecycle linked", { sdlc: next }, `issue #${identity!.issue}`) : task;
+  }
+
+  /**
+   * #694: the PR the hub can verify for a done, without writing it: the one open PR whose head is the done's full commit
+   * (or, with no commit, its branch). The read's basis travels with it, so a task whose commit or branch changed while the
+   * read was awaited never receives a PR found for another head. The done persists it only after its gates admit it, so a
+   * refused done stays effect-free (#254).
+   */
+  private async identityLink(task: Task, refs?: TaskRefs): Promise<IdentityLink | undefined> {
+    if (this.isPii(task) || task.sdlc?.pr) return undefined;
+    const repository = task.sdlc?.repo ?? task.refs.repo ?? this.d.repository;
+    const commit = refs?.commit ?? task.refs.commit, branch = refs?.branch ?? task.refs.branch;
+    if (!repository || !commit && !branch) return undefined;
+    const pr = await openPrFor(repository, commit ? { commit } : { branch }, this.d.sdlc?.gh ?? sdlcGh);
+    return pr ? { repo: repository, pr, basis: { commit, branch } } : undefined;
+  }
+
+  /**
+   * The task as the done's gates see it: the issue the current task names (re-resolved now, so a changed title or refs
+   * counts) and the staged PR only while the done's effective commit and branch are still the ones it was read for.
+   */
+  private withLink(task: Task, link: IdentityLink | undefined, refs?: TaskRefs): Task {
+    if ((this.d.sdlc?.config().mode ?? "off") === "off" || this.isPii(task)) return task;
+    const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
+    let issue: { repo: string; issue: number } | undefined;
+    if (!task.sdlc?.issue) { try { issue = this.planIssueIdentity(task); } catch { issue = undefined; } }
+    const commit = refs?.commit ?? task.refs.commit, branch = refs?.branch ?? task.refs.branch;
+    const repository = task.sdlc?.repo ?? task.refs.repo ?? this.d.repository;
+    const pr = link && !task.sdlc?.pr && repository?.toLowerCase() === link.repo.toLowerCase() && link.basis.commit === commit && (commit !== undefined || link.basis.branch === branch) ? link : undefined;
+    let next = task.sdlc;
+    if (issue) next = linkedReceipt(next, issue, config) ?? next;
+    if (pr) next = linkedReceipt(next, { repo: pr.repo, pr: pr.pr }, config) ?? next;
+    return next === task.sdlc ? task : { ...task, sdlc: next };
+  }
+
   private planIssueIdentity(task: Task): { repo: string; issue: number } | undefined {
     const source = task.external ?? task.sdlc;
     if (source?.repo && source.issue) return { repo: source.repo, issue: source.issue };
@@ -2291,12 +2477,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;
@@ -2339,6 +2529,113 @@ export class Tasks {
     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);
+    }
+    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. */
   async costReport(by: PeerId, repository?: unknown, scopePrs?: readonly number[]): Promise<Record<string, unknown>> {
     const authority = () => {
@@ -2432,8 +2729,9 @@ export class Tasks {
     const current = this.need(task.id, false, true, true);
     if (current.history.length !== flow || (current.planningRevision ?? 0) !== revision) throw new PreEffectToolRefusal("plan review changed during readback");
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
-    const updated = this.d.board.update(current.id, by, "plan reviewed", { ...(Object.keys(scope).length ? { plan: { ...current.plan, ...scope } } : {}), sdlc: { ...current.sdlc, stage: current.sdlc?.stage ?? lifecycleStage(config, "plan"),
+    let updated = this.d.board.update(current.id, by, "plan reviewed", { ...(Object.keys(scope).length ? { plan: { ...current.plan, ...scope } } : {}), sdlc: { ...current.sdlc, stage: current.sdlc?.stage ?? lifecycleStage(config, "plan"),
       planReview: { planner: by, planningRevision: revision, recordedAt: Date.now(), ...(Object.keys(scope).length ? { scope } : {}), ...(issue ? { issue } : {}) } } }, raw.reason.trim(), { ...(withheld ? { withheld: true } : {}) }, flow);
+    if (config.mode !== "off") updated = this.linkIssue(updated); // #694
     if (updated.state === "proposed" && !updated.owner) {
       this.offered.delete(updated.id);
       try { await this.offerReady(updated, "planner review recorded"); }
@@ -2448,7 +2746,11 @@ export class Tasks {
     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);
     const next = sdlcReceipt(input, task.sdlc, config, VERSION);
+    // The spec identity is person-owned in enforce. No observation cache or restart can reopen a relink bypass.
+    const specRelink = (task.sdlc?.repo !== undefined && next.repo !== task.sdlc.repo) || (task.sdlc?.issue !== undefined && next.issue !== task.sdlc.issue);
+    if (config.mode === "enforce" && by !== USER && specRelink) throw new PreEffectToolRefusal("only the person may relink an established repository or issue in enforce");
     const definition = stageDefinition(config, next.stage);
+    if (next.redFirst && input && typeof input === "object" && "redFirst" in input && !this.isPii(task) && !this.publicMetadataText(JSON.stringify(next.redFirst))) throw new PreEffectToolRefusal("red-first metadata matches a PII pattern; use private work");
     // #481 S1: entering a build stage in enforce needs the person's spec acceptance; the person may move any stage.
     if (config.mode === "enforce" && by !== USER && next.stage !== task.sdlc?.stage && definition && canonicalStage(definition.base) === "build" && specState(next, undefined) === "missing") throw new PreEffectToolRefusal(this.specText(task, "missing", "blocked"));
     if (config.mode === "enforce" && config.definitions && input && typeof input === "object" && "stage" in input && next.stage !== task.sdlc?.stage && by !== USER) {
@@ -2476,7 +2778,7 @@ export class Tasks {
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
     const before = workflowHash(this.d.board.list().map(t => ({ id: t.id, state: t.state, after: t.deps, sdlc: t.sdlc, history: t.history.length })));
     const links = 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) } }));
-    const report = await readMergeQueue(repo, config, links, this.d.sdlc?.gh);
+    const report = await readMergeQueue(repo, config, links, this.d.sdlc?.gh, this.publicMetadataText);
     // Policy can change across remote awaits without any board write. Never return its stale public projection.
     const currentPrivacy = this.d.board.list().map(task => ({ id: task.id, private: this.isPii(task) }));
     if (workflowHash(links.map(({ id, private: hidden }) => ({ id, private: hidden }))) !== workflowHash(currentPrivacy)) {
@@ -2492,6 +2794,13 @@ export class Tasks {
         this.capturePlanHead(task, row.head);
       }
     }
+    for (const row of report.rows) if (row.testIntegrity) {
+      row.testIntegrity = row.testIntegrity.map(item => ({ ...publicTestIntegrity(item, this.publicMetadataText), ...(item.task === undefined ? {} : { task: item.task }) }));
+      if (config.mode === "enforce") {
+        row.blockers = [...new Set([...row.blockers, ...row.testIntegrity.flatMap(testIntegrityBlockers)])];
+        row.ready = row.ready && row.blockers.length === 0;
+      }
+    }
     return report;
   }
   async releaseReadiness(repo: string, liveIssues: number[]) {
@@ -2621,16 +2930,18 @@ export class Tasks {
   async lifecycleStatus(id: unknown, refresh = true): Promise<SdlcStatus> {
     const task = this.need(id), config = this.d.sdlc?.config() ?? sdlcConfig(undefined), identity = this.planIdentity(task);
     const valid = () => { const now = this.need(id, false, true); if (this.planIdentity(now) !== identity || now.history.length !== task.history.length) throw new PreEffectToolRefusal("task changed during lifecycle readback"); return now; };
-    const read: SdlcGh = (args, timeout, cwd, cap) => { valid(); return (this.d.sdlc?.gh ?? sdlcGh)(args, timeout, cwd, cap); };
-    const evidence = task.sdlc && !this.isPii(task) && refresh && config.mode !== "off" ? await readSdlcPr(task.sdlc, read) : undefined;
+    const deadline = performance.now() + 20_000;
+    const read: SdlcGh = (args, timeout, cwd, cap) => { valid(); const remaining = deadline - performance.now(); return remaining > 0 ? (this.d.sdlc?.gh ?? sdlcGh)(args, Math.min(timeout ?? 10_000, remaining), cwd, cap) : Promise.resolve({ code: 1, stdout: "" }); };
+    const evidence = task.sdlc && !this.isPii(task) && refresh && config.mode !== "off" ? await readSdlcPr(task.sdlc, read, true) : undefined;
     valid();
     const accepted = task.sdlc?.acceptance;
     const edit = accepted && !this.isPii(task) && refresh && config.mode !== "off" ? await readSpecEdit(accepted.repo, accepted.issue, read) : undefined;
+    const integrity = config.mode !== "off" ? publicTestIntegrity(task.sdlc && evidence && !this.isPii(task) ? await readTestIntegrity(task.sdlc, evidence, read) : this.unknownTestIntegrity(this.isPii(task)), this.publicMetadataText) : undefined;
     const current = valid();
     if (this.planIdentity(current) !== this.planIdentity(task) || current.history.length !== task.history.length) throw new PreEffectToolRefusal("task changed during lifecycle readback");
     this.capturePlanRead(current, evidence);
     return sdlcStatus(config, current.sdlc, evidence, this.workflowView(current), edit, this.isPii(current) ? [] : this.reviewFindingSets(current), current.refs.commit,
-      config.mode !== "off" ? this.planReport(this.d.board.get(current.id)!, evidence) : undefined);
+      config.mode !== "off" ? this.planReport(this.d.board.get(current.id)!, evidence) : undefined, integrity);
   }
 
   /** #481 S1: only build work starts from an accepted spec. */
@@ -2696,26 +3007,33 @@ export class Tasks {
     this.d.notify(this.specText(task, state, "advice"));
   }
 
+  private unknownTestIntegrity(privateTask = false): TestIntegrity {
+    return { applicability: "unknown", redFirst: "unknown", fileState: "unknown", modifiedTests: [], blockers: [privateTask ? "test integrity: private evidence unavailable" : "test integrity: current evidence unknown"] };
+  }
+
   private async lifecycleGate(task: Task, transition: "review" | "approval", reviewedHead?: string, findings?: readonly ReviewFindingSet[]): Promise<PrEvidence | undefined> {
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
     if (config.mode === "off") return;
     const receipt = task.sdlc && { ...task.sdlc, ...(reviewedHead ? { reviewedHead } : {}) };
+    const deadline = performance.now() + 20_000;
     const read: SdlcGh = (args, timeout, cwd, cap) => {
       const current = this.need(task.id, false, true);
       if (current.history.length !== task.history.length || current.owner !== task.owner || current.reviewer !== task.reviewer || this.isPii(current) !== this.isPii(task)) return Promise.resolve({ code: 1, stdout: "" });
-      return (this.d.sdlc?.gh ?? sdlcGh)(args, timeout, cwd, cap);
+      const remaining = deadline - performance.now();
+      return remaining > 0 ? (this.d.sdlc?.gh ?? sdlcGh)(args, Math.min(timeout ?? 10_000, remaining), cwd, cap) : Promise.resolve({ code: 1, stdout: "" });
     };
-    const evidence = receipt && !this.isPii(task) ? await readSdlcPr(receipt, read) : undefined;
+    const evidence = receipt && !this.isPii(task) ? await readSdlcPr(receipt, read, true) : undefined;
+    const integrity = publicTestIntegrity(receipt && evidence && !this.isPii(task) ? await readTestIntegrity(receipt, evidence, read) : this.unknownTestIntegrity(this.isPii(task)), this.publicMetadataText);
     const current = this.need(task.id, false, true);
     if (config.mode === "enforce" && (current.history.length !== task.history.length || current.owner !== task.owner || current.reviewer !== task.reviewer || current.state !== task.state)) throw new PreEffectToolRefusal(`task #${task.id}: changed during lifecycle readback; retry on current work`);
     // Advise may continue on the current task, but evidence from its previous link cannot admit that task's review.
     if (current.history.length !== task.history.length || current.owner !== task.owner || current.reviewer !== task.reviewer || current.state !== task.state || this.isPii(current) !== this.isPii(task)) return;
     this.capturePlanRead(current, evidence);
     const planReport = this.planReport(current, evidence);
-    const status = sdlcStatus(config, receipt, evidence, this.workflowView(current), undefined, this.isPii(current) ? [] : findings ?? this.reviewFindingSets(current), current.refs.commit, planReport);
-    const blockers = transition === "review" ? [...new Set([...status.blockers.filter(blocker => ["lifecycle stage definition unknown", "issue identity missing", "PR identity missing", "current PR evidence unknown", "PR is not open", "local gate on current head missing or failed"].includes(blocker)), ...(status.entry ?? []), ...(status.exit ?? [])])] : status.blockers;
+    const status = sdlcStatus(config, receipt, evidence, this.workflowView(current), undefined, this.isPii(current) ? [] : findings ?? this.reviewFindingSets(current), current.refs.commit, planReport, integrity);
+    const blockers = transition === "review" ? [...new Set([...status.blockers.filter(blocker => ["lifecycle stage definition unknown", "issue identity missing", "PR identity missing", "current PR evidence unknown", "PR is not open", "local gate on current head missing or failed"].includes(blocker) || blocker.startsWith("test integrity:")), ...(status.entry ?? []), ...(status.exit ?? [])])] : status.blockers;
     if (config.mode === "enforce" && blockers.length) throw new PreEffectToolRefusal(`task #${task.id}: SDLC ${transition} blocked: ${blockers.join("; ")}`);
-    const advice = [...new Set([...blockers, ...planConformanceBlockers(planReport)])];
+    const advice = [...new Set([...blockers, ...planConformanceBlockers(planReport), ...testIntegrityBlockers(integrity)])];
     if (config.mode === "advise" && advice.length) this.d.notify(`task ${this.publicTitle(task)}: SDLC ${transition} advice: ${this.isPii(task) ? "private lifecycle evidence unknown" : advice.join("; ")}`);
     return evidence;
   }
@@ -2829,7 +3147,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);
@@ -2946,10 +3264,14 @@ export class Tasks {
       await this.planEntryGate(by, admission);
       task = valid();
     }
+    // #694: stage the identities the hub can verify; the gates read them, and only the admitted done persists them.
+    const link = this.d.sdlc && this.d.sdlc.config().mode !== "off" ? await this.identityLink(task, refs) : undefined;
+    const current = () => this.withLink(valid(), link, refs);
+    task = current();
     let reviewEvidence: PrEvidence | undefined;
-    if (this.d.sdlc && this.d.sdlc.config().mode !== "off") { reviewEvidence = await this.lifecycleGate(task, "review"); task = valid(); }
-    const reviewAdmission = task.reviewer ? await this.reviewRequestAdmission(task, refs, true, by, reviewEvidence) : undefined;
-    task = valid();
+    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(staged, 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);
     const silentMember = !!cohort?.silent && this.turnFree() && !!task.owner && !this.isPii(task);
@@ -2969,8 +3291,8 @@ export class Tasks {
       if (r.action === "request") return this.d.board.update(task.id, HUB, "integration requested", {}, this.integrationRequest(task, r));
       if (r.action === "unresolved") {
         this.d.notify(`task ${this.publicTitle(task)}: turn-free integration unresolved after ${MAX_REQUESTS} requests (${r.why}); its done is recorded, check the overlapping work by hand`);
-        task = this.d.board.update(task.id, HUB, "integration unresolved", {}, r.why);
-      } else if (r.integrated) task = this.d.board.update(task.id, HUB, "integrated", {}, `cohort #${cohort!.id}, revision ${cohort!.revision}`);
+        task = this.withLink(this.d.board.update(task.id, HUB, "integration unresolved", {}, r.why), link, refs);
+      } else if (r.integrated) task = this.withLink(this.d.board.update(task.id, HUB, "integrated", {}, `cohort #${cohort!.id}, revision ${cohort!.revision}`), link, refs);
     } else if (cohort?.held.size && !this.isPii(task)) {
       // No integration step for this member (silence lifted, a PII task open): the notices the silence held stand in
       // for it (issue #107, AC4).
@@ -2978,14 +3300,14 @@ export class Tasks {
       if (evidence && by === USER) this.d.notify(`task ${this.publicTitle(task)} done by the console; overlapping work finished meanwhile:\n${evidence}`);
       else if (evidence) this.doneNotes.set(task.id, `Overlapping work finished while you worked (no turn-free integration step ran):\n${evidence}`);
     }
-    if (task.state === "proposed" || task.state === "changes_requested") task = this.d.board.update(task.id, by, "accepted", { state: "in_progress" }, WITH_DONE); // done without a separate accept
+    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);
+    if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission, link);
     // 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)", { refs: checkedRefs }, summary, { withheld: withheld || undefined });
+    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);
     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++;
@@ -3033,7 +3355,7 @@ export class Tasks {
         const theirs = this.places(u);
         if (mine.repositoryKey !== theirs.repositoryKey) return [];
         const paths = t.profile && u.profile && (t.plan?.sections?.length && u.plan?.sections?.length) ? [] : mine.paths.filter((p) => theirs.paths.some((q) => samePlace(p, q)));
-        const symbols = mine.symbols.filter((x) => theirs.symbols.includes(x));
+        const symbols = mine.symbols.filter((x) => theirs.symbols.some((y) => symbolsOverlap(x, y)));
         return paths.length || symbols.length ? [this.completedNotice(u, { task: t, paths, symbols }, at.note, at.withheld)] : [];
       });
       if (!open.length && !done.length) continue;
@@ -3116,19 +3438,19 @@ 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): Promise<Task> {
+  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review", admission?: ReviewReadiness, link?: IdentityLink): Promise<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");
-      task = this.completionCurrent(task.id, by, false);
+      task = this.withLink(this.completionCurrent(task.id, by, false), link, refs);
       selection = this.poolReview(task, refs);
       reviewer = selection?.reviewer ?? task.reviewer;
     }
-    // A delayed local check needs a new readback; the immediate done path already admitted before effects.
-    if (reviewer && !admission && (this.d.sdlc?.config().mode ?? "off") !== "off") {
-      admission = await this.reviewRequestAdmission(task, refs, false, by, reviewEvidence);
-      task = this.completionCurrent(task.id, by, false);
+    // 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);
+      task = this.withLink(this.completionCurrent(task.id, by, false), link, refs);
     }
     selection = this.poolReview(task, refs);
     reviewer = selection?.reviewer ?? task.reviewer;
@@ -3138,7 +3460,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", { 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 } : {}) });
+    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);
     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);
@@ -3148,7 +3470,7 @@ export class Tasks {
       this.releaseNotice(`task ${this.publicTitle(next)} done by ${by}, no reviewer: approved`);
       await this.releaseDependents(next);
     }
-    else if (reviewer === USER) this.releaseNotice(`task ${this.publicTitle(next)} done by ${by}: review it with ahub task show ${next.id}, then ahub review ${next.id} approved|changes_requested [note]`);
+    else if (reviewer === USER) this.releaseNotice(`task ${this.publicTitle(next)} done by ${by}: review it in the ahub console (Tasks, select #${next.id}, press r) or with ahub review ${next.id} approved|changes_requested [note]`);
     else this.releaseNotice(`task ${this.publicTitle(next)}: could not send the review request to ${reviewer}`, () => this.sendReview(next, reviewer, "", admission));
     return next;
   }
@@ -3162,6 +3484,9 @@ export class Tasks {
     const hits = this.overlapHits(task).filter((h) => h.task.owner !== USER && h.task.owner !== HUB);
     const cohort = this.cohorts.of(task.id);
     const silent = this.silentFor(task.id);
+    // #713: one notice per recipient per done, naming all of that recipient's overlapping tasks, and only for work the recipient has accepted. An offered or proposed
+    // task has nothing to check yet (its offer, or the accept that follows, already shows the current board), and a repeat done replaces the queued notice (see Bus.enqueue).
+    const byOwner = new Map<PeerId, typeof hits>();
     for (const hit of hits) {
       // A member of the same silent cohort (issue #107): the member that finishes last integrates instead
       // (Cohorts.completion). The notice is held, so something replaces it if no integration runs. Others hear it.
@@ -3169,9 +3494,23 @@ export class Tasks {
         cohort.held.add(task.id);
         continue;
       }
-      this.releaseNotice(`task ${this.publicTitle(task)}: could not publish the completed-change notice to ${hit.task.owner}`, () =>
-        this.whileOpen(hit.task.owner!, hit.task.id, this.completedNotice(task, hit, summary, withheld)));
+      // Accepted by its own owner since it last changed hands (`ownerAcceptance`, the rule the rest of this class uses), and still in work or review: an offered or proposed task is not.
+      if (!["in_progress", "changes_requested", "in_review"].includes(hit.task.state) || !this.ownerAcceptance(hit.task)) continue;
+      byOwner.set(hit.task.owner!, [...(byOwner.get(hit.task.owner!) ?? []), hit]);
     }
+    for (const [owner, mine] of byOwner) {
+      this.releaseNotice(`task ${this.publicTitle(task)}: could not publish the completed-change notice to ${owner}`, () =>
+        this.whileOpenFor(owner, task.id, mine.map((h) => h.task.id), this.completedNotice(task, mine, summary, withheld)));
+    }
+  }
+
+  /** Share the same screened observation rule between completion notices and read-only console detail. */
+  private sameFileDifferentSymbols(task: Task, hit: { task: Task; paths: string[] }): boolean {
+    const symbolRepository = task.codeSymbols && !this.isPii(task) ? this.codeSymbolsRepository(task) : undefined;
+    const otherRepository = hit.task.codeSymbols && !this.isPii(hit.task) ? this.codeSymbolsRepository(hit.task) : undefined;
+    return !!symbolRepository && symbolRepository.key === otherRepository?.key && !this.isPii(task) && !this.isPii(hit.task) && taskCodeSymbolsDisjoint(
+      task.codeSymbols, hit.task.codeSymbols, this.reviewHead(task), this.reviewHead(hit.task), symbolRepository.key,
+      hit.paths, false, this.publicMetadataText);
   }
 
   /**
@@ -3179,13 +3518,18 @@ export class Tasks {
    * included), and any item that matches a PII pattern is left out of what other owners get, the summary also when the
    * PII screen did not clear it (`withheld`, #198).
    */
-  private completedNotice(task: Task, hit: { task: Task; paths: string[]; symbols: string[] }, summary?: string, withheld = false): string {
+  private completedNotice(task: Task, hitOrHits: { task: Task; paths: string[]; symbols: string[] } | { task: Task; paths: string[]; symbols: string[] }[], summary?: string, withheld = false): string {
+    const hits = Array.isArray(hitOrHits) ? hitOrHits : [hitOrHits];
     const paths = this.places(task).paths.filter(this.nameable);
     const signatures = (task.plan?.signatures ?? []).filter(this.nameable);
     const first = (summary ?? "").split("\n").find((l) => l.trim())?.trim().slice(0, 300);
     const line = first && !withheld && this.nameable(first) ? first : undefined;
+    // One line per overlapping task of the recipient, so a single notice names all of them (#713).
+    const touches = hits.map((hit) => `#${hit.task.id} on ${this.where(hit)}${this.sameFileDifferentSymbols(task, hit) ? " (same file, different symbols; observed names only, deleted definitions may be missing)" : ""}`);
+    const open = hits.length > 1 ? `your open tasks ${touches.join("; ")}` : `your open ${touches[0]}`;
+
     return [
-      `Task #${task.id} (owner ${task.owner}) is done and touches your open #${hit.task.id} on ${this.where(hit)}. Check your work against it before you go on.`,
+      `Task #${task.id} (owner ${task.owner}) is done and touches ${open}. Check your work against it before you go on.`,
       paths.length ? `Changed files: ${paths.join(", ")}` : "",
       signatures.length ? `New or changed signatures: ${signatures.join("; ")}` : "",
       line ? `Summary: ${line}` : "",
@@ -3226,16 +3570,17 @@ export class Tasks {
 
   /** The one place a review request is written: the first reviewer and a replacement get the same text, refs and privacy. */
   /** Review admission is separate from brief construction (#228). All refusals precede the requesting done's writes. */
-  private async reviewRequestAdmission(task: Task, refs?: TaskRefs, preEffect = true, actor: PeerId = task.owner ?? USER, previous?: PrEvidence, sameRequest?: () => boolean): Promise<ReviewReadiness | undefined> {
+  private async reviewRequestAdmission(task: Task, refs?: TaskRefs, preEffect = true, actor: PeerId = task.owner ?? USER, previous?: PrEvidence, sameRequest?: () => boolean, stage: (task: Task) => Task = task => task, prepareOnly = false): Promise<ReviewReadiness | undefined> {
     const mode = (this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode;
-    if (mode === "off") return undefined;
+    if (mode === "off" && !this.d.prepareReviewBrief) return undefined;
     let quietDrift = false;
     const guard = () => {
       if (actor !== USER && actor !== task.owner) {
         const holders = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([peer]) => peer);
         if (holders.length !== 1 || holders[0] !== actor) throw new (preEffect ? PreEffectToolRefusal : Error)("review admission authority changed");
       }
-      const current = this.need(task.id, false, preEffect);
+      // #694: the board copy seen through the same staged identity link the caller's task carries.
+      const current = stage(this.need(task.id, false, preEffect));
       const changed = current.history.length !== task.history.length;
       const quiet = current.history.length > task.history.length && current.history.slice(task.history.length).every(entry => QUIET_EVENTS.has(entry.event));
       const sameHistory = !changed || (mode === "advise" && quiet) || !!sameRequest?.();
@@ -3247,6 +3592,12 @@ export class Tasks {
       return current;
     };
     guard();
+    if (!this.isPii(task) && this.d.prepareReviewBrief) {
+      try { await this.d.prepareReviewBrief({ ...task, refs: { ...task.refs, ...cleanRefs(refs) } }); }
+      catch { /* Optional code facts must not refuse a review. */ }
+      guard();
+    }
+    if (mode === "off" || prepareOnly) return undefined;
     const expected = cleanRefs(refs).commit ?? task.refs.commit ?? task.sdlc?.head ?? task.sdlc?.localHead;
     const read: SdlcGh = (args, timeout, cwd, cap) => {
       guard();
@@ -3283,12 +3634,26 @@ export class Tasks {
     const cachedPlanRead = this.planReads.get(task.id);
     const planRead = this.planReport(task, cachedPlanRead?.identity === this.planReadIdentity(task) && cachedPlanRead.evidence.head === this.findingHead(task) ? cachedPlanRead.evidence : undefined);
     const conformanceText = mode !== "off" ? this.screen(task, `Plan conformance: ${JSON.stringify(planRead)}`, "plan conformance", reviewer) + "\n" : "";
+    const profile = (task.profile ?? "dev") === (this.d.profile ?? "dev") ? profileData(this.d.profileData ?? task.profile ?? "dev") : profileData(task.profile);
+    const target = plan ? `the plan (${plan})` : task.detail ? "the task detail above" : "the task title";
+    const noCheckWording = profile.name === "research" || profile.name === "writing"
+      ? "No check ran for this class: verify the claims and sources yourself."
+      : profile.name === "general"
+        ? "No check ran for this class: verify the outcome yourself."
+        : "No check ran for this class: run the affected tests yourself.";
+    const checkResult = check ? `Check result: ${(check.note ?? "").split("\n")[0]}` : noCheckWording;
+    const checklistTemplates = profile.review_checklist ?? [
+      "Map the changed signatures and call sites to {target}, and name each one that does not match.",
+      "{check}",
+      "List what is unmet in hub_review's unmet, one item each.",
+    ];
+    const checklistLines = checklistTemplates.map(template =>
+      template.replaceAll("{target}", target).replaceAll("{check}", checkResult)
+    );
     const checklist = [
       "Checklist:",
       ...this.planGuardItems(task).map(item => `- Check the plan against this live fail before the remaining checks: ${item.line}`),
-      `- Map the changed signatures and call sites to ${plan ? `the plan (${plan})` : task.detail ? "the task detail above" : "the task title"}, and name each one that does not match.`,
-      `- ${check ? `Check result: ${(check.note ?? "").split("\n")[0]}` : "No check ran for this class: run the affected tests yourself."}`,
-      `- List what is unmet in hub_review's unmet, one item each.`,
+      ...checklistLines.map(line => `- ${line}`),
     ].join("\n");
     // #223 R2: a reviewer-only instance judges from facts; the builder's narrative stays out, earlier findings go in.
     const reviewOnly = this.d.reviewOnly?.(reviewer) === true;
@@ -3345,6 +3710,29 @@ export class Tasks {
     return next;
   }
 
+  private codeSymbolsRepository(task: Task) {
+    try {
+      const repository = this.repositories.scope(task.refs);
+      if (task.sdlc?.repo && this.repositories.scope({ repo: task.sdlc.repo }).key !== repository.key) return undefined;
+      return repository;
+    } catch { return undefined; }
+  }
+
+  /** Host observations are saved only with an admitted transition, never by an optional read. */
+  private observedCodeSymbols(task: Task) {
+    if (this.isPii(task) || !task.refs.commit) return undefined;
+    const repository = this.codeSymbolsRepository(task);
+    // ponytail: the brief analyzes the validated project execution root. Foreign repositories stay unknown
+    // until the brief carries independent repository provenance; a model's refs.repo cannot supply that proof.
+    if (!repository || repository.key !== this.repositories.project.key) return undefined;
+    try {
+      const brief = this.d.reviewBrief?.(task);
+      const observation = brief && !("unavailable" in brief) ? buildTaskCodeSymbols(brief, repository.key, this.publicMetadataText) : undefined;
+      // A resolved short ref or a stale provider result is unknown advice, never a reason to refuse done.
+      return observation?.head === task.refs.commit ? observation : undefined;
+    } catch { return undefined; } // Optional metadata never costs the admitted result.
+  }
+
   /** #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 "";