@staix/agent-hub 0.20.0 → 0.22.0

package/src/hub/tasks.ts

@@ -1,21 +1,28 @@
+import type { ContextAdmission } from "./context-window.ts";
+import { queueBackpressure, queueBackpressurePolicy, type QueueBackpressureCode, type QueueBackpressurePolicy, type QueueBackpressureStatus, type QueuePressure } from "./queue-backpressure.ts";
 import { canonicalMemorySymbolNode, normalizeMemorySymbolInput, MEMORY_SYMBOL_LIMIT, type MemorySymbolNodes } from "./memory-symbols.ts";
 import { createHash } from "node:crypto";
 import { taskShellBindingValid, type TaskShellBinding } from "./task-shell-command.ts";
 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 { evalAdvice, evalGapBlockers, evalRequiredChecks, readEvalFor } from "./eval-gate.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 { qualifiedTitleRepos, siblingTitleRefs, specRefs } from "./spec-read.ts";
-import { sdlcMetrics, type BandResult, type MetricTask, type MetricsReport } from "./sdlc-metrics.ts";
+import { folderDetail, MAX_NEW_PER_POLL, parseEvery, SOURCE_ID, scheduledDetail, scheduleKeyOf, type FolderEntry, type FolderRunResult, type FolderScan, type FolderStorePort, type ScannedFile, type ScheduleEntry, type ScheduleRunResult, type ScheduleStore } from "./schedules.ts";
+import { INTAKE_MAX_SOURCES, INTAKE_MAX_TEXT, intakeDetail, intakeSystemPrompt, intakeUserMessage, parseIntakeDetail, parseIntakeSplit, plannerRequestBody } from "./intake.ts";
+import { DEFAULT_BAND, EPISODE_LOOKBACK, sdlcMetrics, type BandMetric, type BandResult, type MetricTask, type MetricsReport, type SeriesPoint } from "./sdlc-metrics.ts";
+import { readSecurityScan } from "./security-baseline.ts";
+import { cleanMergeCost } from "./cost-governance.ts";
 import type { InstancesConfig } from "./instances.ts";
 import { composeRememberText } from "./memory-fail.ts";
 import { VERSION } from "../version.ts";
 import { NoWriteTurns } from "./no-writes.ts";
 import { readGitHubImport, type GitHubSource, type GitHubImportSelection } from "./github-import.ts";
 import { BACKLOG_SPLIT_SCREEN_TIMEOUT_MS, actualTaskDates, planningPatch, type PlanningFields, type Release, type ReleaseState } from "./planning.ts";
-import { readMergeQueue, type DeliveryTask } from "./sdlc-queue.ts";
+import { readMergeQueue, type DeliveryTask, type MergeQueue } from "./sdlc-queue.ts";
 import { guardedMerge, mergeModeFor, mergeView, type MergeView } from "./sdlc-merge.ts";
 import { mirrorVerdict as mirrorToGitHub, type MirrorVerdict } from "./sdlc-mirror.ts";
 import { CODE_SCOPE_LINE, evidenceOnlyNotice, type ReviewScope } from "./review-scope.ts";
@@ -28,17 +35,27 @@ 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, unmetCriteriaIds, workflowHash } from "./workflow.ts";
+import { candidateCard, criterionKey, groupUnmetCriteria, LEARNING_DEFAULTS, overridesDiff, parseCandidateCard, selectGroups, type CriterionGroup } from "./learning.ts";
+/** #514b: how a closed candidate card says what the person decided; `learnCandidates` reads them back. */
+const LEARN_ACCEPTED = "candidate accepted", LEARN_REJECTED = "candidate rejected";
+/** What the person decided on a candidate card, read from its cancellation: only an entry the person wrote counts, so no other note can pass for a verdict. Undefined while it is open or closed for another reason. */
+const learnVerdict = (card: Pick<Task, "state" | "history">): "accepted" | "rejected" | undefined => {
+  if (card.state !== "cancelled") return undefined;
+  const closed = card.history.findLast(entry => entry.event === "cancelled");
+  if (!closed || closed.by !== USER) return undefined;
+  return closed.note?.startsWith(LEARN_ACCEPTED) ? "accepted" : closed.note?.startsWith(LEARN_REJECTED) ? "rejected" : undefined;
+};
 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";
 import { candidateTargetRevision, type CandidateInput, type CandidateStore, extractNodes, looksSecret, PROMOTED_KINDS, taskKey, type GoalView, type Kind, type MemoryStore, type Scope, type Tier } from "@staix/agent-mem";
-import { CLASSES, OUTCOMES_KEPT_MS, ALL_PLAN_KEYS, TASK_MOVE_REASONS, taskCanPlan, taskHasWorkEvidence, taskHasStarted, planningUndoEntry, isClosedTaskState, type TaskStall, type HistoryEntry, type ReviewerHistory, type Board, type Task, type TaskClass, type TaskMoveReason, type TaskPlan, type TaskRefs, type PlannerBinding } from "./board.ts";
+import { parseClaimVerdict, claimListId, CLASSES, OUTCOMES_KEPT_MS, ALL_PLAN_KEYS, TASK_MOVE_REASONS, taskCanPlan, taskHasWorkEvidence, taskHasStarted, planningUndoEntry, isClosedTaskState, type TaskStall, type HistoryEntry, type ReviewerHistory, type Board, type Task, type TaskClass, type TaskMoveReason, type TaskPlan, type TaskRefs, type PlannerBinding } from "./board.ts";
 import type { Bus } from "./bus.ts";
 import { HUB, newEnvelope, NOTE_KINDS, noteLine, sanitize, USER, type Envelope, type PeerId, type PeerState } from "./envelope.ts";
 import type { PiiVerdict, ScreenItem, ScreenRecord } from "./inference.ts";
-import { assign, detectSignals, peerEntry, predictSplit, relayCandidates, type Assignment, type InstanceRoutingOptions, type PeerCapabilities, type Routing, type SplitObservation, type SplitPrediction } from "./routing.ts";
+import { assign, isRemotePeerId, detectSignals, peerEntry, predictSplit, relayCandidates, type Assignment, type InstanceRoutingOptions, type PeerCapabilities, type Routing, type SplitObservation, type SplitPrediction } from "./routing.ts";
 import { ExecutionBudget, type ExecutionBudgetConfig, type ExecutionBudgetDecision, type ExecutionBudgetStatus, type ExecutionUnit } from "./execution-budget.ts";
 import { Cohorts, MAX_REQUESTS, type Cohort, type Completion } from "./cohorts.ts";
 import { realPath } from "./project.ts";
@@ -52,6 +69,10 @@ import { plannerGrooming, nextSweep, taskSweepConfig, type TaskSweepConfig, type
 import { CiWatchers, pollCi, type CiOutcome, type CiWatch } from "./ci-watch.ts";
 import { planningIssueReceipt, 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 MergeRecord, type PlanIssueMetadata, sdlcGh, type SdlcGh, type SdlcStatus, type SpecEdit, type SpecState } from "./sdlc.ts";
 
+function requireLocalTaskPeer(peer: unknown): void {
+  if (isRemotePeerId(peer)) throw new PreEffectToolRefusal("remote peers have no local task authority");
+}
+
 export type TaskAssignmentRole = "owner" | "reviewer" | "planner";
 
 export interface ReleaseWindow { at: number; host: boolean; quota: boolean; idle: boolean; reasons: string[]; current?: () => boolean; close?: () => Promise<void>; }
@@ -68,6 +89,10 @@ export interface TasksDeps {
   board: Board;
   bus: Bus;
   routing: () => Routing;
+  /** #800: normalized machine-local admission policy; absent or both zero preserve the old queue behaviour. */
+  queueBackpressure?: () => QueueBackpressurePolicy;
+  /** Host-only native context snapshots, separate from checkpoint notification and quota. */
+  contextAdmission?: () => ContextAdmission;
   /** Startup-bound project declarations; routing never discovers instances from peer names. */
   instances?: () => InstancesConfig;
   /** Host proof of each live extra runtime's actual isolated execution root; config paths alone are not proof. */
@@ -120,6 +145,11 @@ export interface TasksDeps {
   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;
+  /**
+   * #933: whether `by` runs this call inside an admitted, audited conductor operation. The host rechecks the role on every call and throws
+   * its authority refusal when it ended; a peer outside such a call gets `false`. Host-only: never read from configuration or a tool.
+   */
+  operational?: (by: PeerId) => boolean;
   memory?: MemoryClient;
   /** Captured native profile fence at our memory operation boundaries; no board mutation. */
   memoryCheck?: () => void;
@@ -129,6 +159,8 @@ export interface TasksDeps {
   notify: (line: string) => void;
   /** The completion check configured for a class, if any (local config only; issue #7). */
   check?: (cls: TaskClass, task?: Task) => string | undefined;
+  /** #901: the key of the `checks` entry `check` chose for this task (the profile class alias, else the class): the same lookup, so the two cannot disagree. Absent: the key is unknown. */
+  checkKey?: (cls: TaskClass, task?: Task) => string | undefined;
   /** Runs one check; the hub runs them one at a time. */
   runCheck?: (command: string) => Promise<{ code: number | null; timedOut: boolean; interrupted?: boolean; tail: string }>;
   /** Hands a saved note to every other peer; it rides on their next delivery. */
@@ -159,6 +191,8 @@ export interface TasksDeps {
   roles?: Record<string, string[]>;
   /** Optional: name a class for a task proposed without one. `onCampus` says whether the model call stays on campus. */
   triage?: { classify: (title: string, detail: string) => Promise<TaskClass | undefined>; onCampus: () => Promise<boolean> };
+  /** #334: natural-language intake. `split` is the hub model's one call, `partsSchema` the profile's `hub_backlog_split` parts schema, `sourceKnown` the source registry. */
+  intake?: { split: (system: string, user: string, opts: { campusOnly: boolean }) => Promise<string | undefined>; partsSchema: () => unknown; sourceKnown: (id: string) => boolean };
   /** The PII screen (issue #198): a closed verdict from a model on this machine or on campus, `unknown` on any failure. */
   piiScreen?: (text: string) => Promise<PiiVerdict>;
   /** Each screen verdict, for the record: item, label, source and category, never the text. */
@@ -191,27 +225,43 @@ export interface TasksDeps {
   /** A cohort formed, changed or was lifted (issue #107), for the record: the benchmark's treatment check reads it. */
   recordCohort?: (cohort: { id: number; event: "formed" | "joined" | "lifted"; silent: boolean; tasks: number[]; owners: PeerId[] }) => void;
   sweep?: TaskSweepConfig;
-  /** Shutdown or coordinator work holds task sweeps too. */
+  /** #798 D1: the project's declared submodule paths, project-relative. Absent: none are known, so no notice. */
+  submodules?: () => string[];
+  /** Shutdown or coordinator work (recovery) holds task sweeps, and a guarded merge at its dispatch (#491). */
   sweepHeld?: () => boolean;
   /** Consecutive changes_requested verdicts that move a task to another peer (`tasks.escalate_after`, #488). */
   escalateAfter?: () => number;
+  /** #489 H1: current host configuration, read at each planner-notice flush; no task/request override. */
+  groomFyiWindowMin?: () => number;
+  /** #489 H2: current host configuration, read at each use (no cache, no task/request override); absent is the constant each replaces. */
+  demoteAt?: () => number;
+  demotionHalfLifeH?: () => number;
+  contradictionWindowDays?: () => number;
+  rescreenMax?: () => number;
+  splitMinObservations?: () => number;
+  splitMaxFailureShare?: () => number;
 }
 
 /** The `tasks.escalate_after` default (#488): the third consecutive changes_requested escalates. */
 export const ESCALATE_AFTER = 3;
 // Demotion (issue #36): a failure counts half after a day. A peer is demoted for a class once its decayed failures
 // reach 1.5 (two within about half a day, three within two days) and outweigh its decayed successes there.
-// ponytail: fixed constants; make them config when someone needs to tune them.
-const DEMOTION_HALF_LIFE_MS = 24 * 3_600_000;
-const DEMOTE_AT = 1.5;
-/** An approval counts as contradicted when work on the same places fails within this window (issue #35). */
-const CONTRADICTION_WINDOW_MS = 7 * 86_400_000;
+// #489 H2: `tasks.demotion_half_life_h` and `tasks.demote_at` set these; unset they are exactly the constants below (pinned in test/operational-settings.test.ts).
+export const DEMOTION_HALF_LIFE_MS = 24 * 3_600_000;
+export const DEMOTE_AT = 1.5;
+/** An approval counts as contradicted when work on the same places fails within this window (issue #35); `tasks.contradiction_window_days` sets it. */
+export const CONTRADICTION_WINDOW_MS = 7 * 86_400_000;
 const OPEN: Task["state"][] = ["proposed", "in_progress", "changes_requested"];
+const QUEUE_PRESSURE_CODES: readonly QueueBackpressureCode[] = ["queue-count", "queue-age", "queue-age-unknown"];
+const isQueuePressureCode = (code: string): code is QueueBackpressureCode => (QUEUE_PRESSURE_CODES as readonly string[]).includes(code);
+const QUEUE_RECHECK_PAGE = 32;
+interface QueuePressurePass { ownerAfter: number; reviewAfter: number; ownerDone: boolean; reviewDone: boolean; retained: boolean; generation: number }
 /** 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.
 QUIET_EVENTS.add("planner changed"); // Planning authority does not move the execution owner or revoke its handoff.
+QUIET_EVENTS.add("claim verdict"); // #901: a person's bookkeeping on a plan claim moves nothing, so it must not turn a running check into "check finished late".
 QUIET_EVENTS.add("shell branch bound"); // #880: the hub's host-observed branch binding (#845) is bookkeeping; it neither moves nor settles the task.
 /** The records of the `done (checking)` entry a passed check now completes: what the owner delivered then (#509a). */
 const latestPendingDeliverables = (task: Task): DeliverableRecord[] | undefined => {
@@ -312,11 +362,11 @@ const planText = (plan: TaskPlan = {}) => ALL_PLAN_KEYS.filter((k) => plan[k]?.l
 /** What the PII screen reads of a task (#198): the text the patterns are checked against. */
 const screenText = (t: { title: string; detail: string; plan?: TaskPlan; external?: Task["external"] }) => [t.title, t.detail, planText(t.plan), t.external?.repo, t.external?.url].filter(value => value !== undefined).join("\n");
 /** Re-screens of one task whose verdict was unknown, per hub run (#198). */
-const RESCREEN_MAX = 10;
+export const RESCREEN_MAX = 10;
 /** #758: the planner "board changed" notice. Its body starts with this, so an unsettled copy is found (and replaced) by the prefix. */
 const GROOM_NOTICE_PREFIX = "The board changed";
 /** #758: a board change that needs no plan review is recorded at most once per planner in this window. */
-const GROOM_FYI_WINDOW_MS = 10 * 60_000;
+export const GROOM_FYI_WINDOW_MS = 10 * 60_000;
 
 /**
  * The task flow. Adapters and tools never touch the board: every change comes through here, where assignment,
@@ -424,15 +474,16 @@ export class Tasks {
   }
 
   /** `signals.pii_screen = "local"` where the PII constraint applies (issue #198); on without a screener, every verdict is unknown. */
-  private screenOn = (): boolean => {
+  screenOn = (): boolean => {
     const r = this.d.routing();
     return r.signals.pii_screen === "local" && r.constraints.pii === "local_only";
   };
 
   /** One bounded screen call. A screener that fails is no verdict, handled as PII (fail closed). */
-  private requestCheck(by: PeerId): () => void {
+  private requestCheck(by: PeerId, fence?: () => string | undefined): () => void {
+    requireLocalTaskPeer(by);
     const authority = this.d.requestAuthority?.(by);
-    const check = () => { const reason = authority?.(); if (reason) throw new PreEffectToolRefusal(reason); };
+    const check = () => { const reason = authority?.() ?? fence?.(); if (reason) throw new PreEffectToolRefusal(reason); };
     check(); return check;
   }
 
@@ -551,6 +602,7 @@ export class Tasks {
 
   /** Captured at native turn start, not supplied by a model. */
   ownerTurnTasks(peer: PeerId): { id: number; acceptance: number }[] {
+    requireLocalTaskPeer(peer);
     return this.d.board.list("in_progress").flatMap(task => {
       const accepted = task.owner === peer && ["implement", "bulk_edit"].includes(task.class) ? this.ownerAcceptance(task) : undefined;
       return accepted ? [{ id: task.id, acceptance: accepted.index }] : [];
@@ -558,6 +610,7 @@ export class Tasks {
   }
 
   recordOwnerTurn(peer: PeerId, bindings: readonly { id: number; acceptance: number }[], changed: boolean | undefined, effect: boolean): void {
+    requireLocalTaskPeer(peer);
     this.noWriteTurns.retain(this.d.board.list("in_progress").filter(task => ["implement", "bulk_edit"].includes(task.class)).map(task => task.id));
     const current = new Map(this.ownerTurnTasks(peer).map(binding => [binding.id, binding.acceptance]));
     for (const binding of bindings) {
@@ -662,6 +715,101 @@ export class Tasks {
     }
     return new Set(rows.map(row => find(row.id))).size;
   }
+  /**
+   * #514b: the person's view of the recurring-criterion candidates (`ahub learn list`). The person only: a conductor or an agent gets a refusal, never a list. A card that does not parse as the
+   * hub's own is not listed. Ids, counts and the key parts only: the card's text is never echoed, and a PII row is never reached because the cards are already screened when filed.
+   */
+  learnCandidates(by: PeerId, opts: { all?: boolean } = {}): Record<string, unknown>[] {
+    if (by !== USER) throw new PreEffectToolRefusal("ahub learn is a person's command");
+    const rows: Record<string, unknown>[] = [];
+    for (const card of this.d.board.list()) {
+      const parsed = parseCandidateCard(card);
+      if ("refused" in parsed) continue;
+      const open = card.state === "backlog" || card.state === "proposed";
+      const closed = card.history.findLast(entry => entry.event === "cancelled");
+      const verdict = learnVerdict(card) ?? (closed ? "closed" : undefined);
+      if (!open && !opts.all) continue;
+      if (!open && !closed) continue;
+      rows.push({ id: card.id, state: card.state, ...parsed, status: open ? "open" : verdict, tasks: this.learnEvidence(parsed).tasks, line: overridesDiff({ ...parsed, tasks: this.learnEvidence(parsed).tasks }).profile_overrides.review_checklist[0] });
+    }
+    return rows;
+  }
+  /** The distinct tasks that name this criterion unmet on this profile and class in the window, from the board as it is now: the count the written line states is recomputed, never read from the card. */
+  private learnEvidence(card: { profile: string; class: string; criterion: string }): { tasks: number[] } {
+    const eligible = this.d.board.list().filter(row => this.candidateTextAllowed(`${row.profile ?? ""} ${row.profileClass ?? ""} ${row.class}`, row));
+    const group = groupUnmetCriteria(eligible, { windowMs: LEARNING_DEFAULTS.windowMs, now: Date.now() }).find(g => g.profile === card.profile && g.class === card.class && g.criterion === card.criterion);
+    return { tasks: group?.tasks ?? [] };
+  }
+  /**
+   * #514b: what `ahub learn accept` would write for card `id`, or why not. Person only. It reads ONLY the card's key line (`parseCandidateCard`), requires the card to be open, and builds the
+   * line from the board's own evidence with `overridesDiff`: nothing of the card's text is parsed as a value. The daemon adds the line to the stored checklist and writes it through the settings path.
+   */
+  learnAcceptPlan(by: PeerId, id: unknown): { id: number; profile: string; class: string; criterion: string; line: string; tasks: number } {
+    if (by !== USER) throw new PreEffectToolRefusal("ahub learn accept is a person's command");
+    const card = this.learnCard(id);
+    const evidence = this.learnEvidence(card);
+    if (!evidence.tasks.length) throw new PreEffectToolRefusal(`no task in the window still names ${card.criterion} unmet on ${card.profile}/${card.class}: nothing to accept; reject the card to close it`);
+    const line = overridesDiff({ ...card, tasks: evidence.tasks }).profile_overrides.review_checklist[0]!;
+    return { id: card.id, profile: card.profile, class: card.class, criterion: card.criterion, line, tasks: evidence.tasks.length };
+  }
+  /**
+   * #514b: whether `ahub learn accept` already decided this card. Person only. A card the person accepted answers `"accepted"`, so a repeat accept is a no-write success (the plan's idempotency);
+   * a rejected card, a card closed some other way and an open one answer undefined and take the normal path, which refuses the closed ones.
+   */
+  learnAccepted(by: PeerId, id: unknown): { id: number; profile: string; class: string; criterion: string } | undefined {
+    if (by !== USER) throw new PreEffectToolRefusal("ahub learn accept is a person's command");
+    if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) return undefined;
+    const task = this.d.board.get(id);
+    if (!task || learnVerdict(task) !== "accepted") return undefined;
+    const parsed = parseCandidateCard(task);
+    return "refused" in parsed ? undefined : { id, ...parsed };
+  }
+  /** The card, which must be an open candidate the hub filed. */
+  private learnCard(id: unknown): { id: number; profile: string; class: string; criterion: string } {
+    if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) throw new PreEffectToolRefusal("id must be a positive task number");
+    const task = this.d.board.get(id);
+    if (!task) throw new PreEffectToolRefusal(`no task #${id}`);
+    const parsed = parseCandidateCard(task);
+    if ("refused" in parsed) throw new PreEffectToolRefusal(`task #${id}: ${parsed.refused}`);
+    if (task.state !== "backlog" && task.state !== "proposed") throw new PreEffectToolRefusal(`task #${id} is already ${task.state === "cancelled" ? "closed" : task.state}`);
+    return { id, ...parsed };
+  }
+  /**
+   * #514b: closes a candidate card after the person's verdict, through `cancel` (never a direct board write): the row stays, the verdict is in its history, and because the dedupe key is the card's
+   * detail the same criterion is never filed again. `accepted` is recorded only after the write succeeded (the daemon calls this last); a repeat of either verdict is refused by `learnCard`.
+   */
+  async learnClose(by: PeerId, id: unknown, verdict: "accepted" | "rejected"): Promise<Task> {
+    if (by !== USER) throw new PreEffectToolRefusal("ahub learn is a person's command");
+    const card = this.learnCard(id);
+    return this.cancel(card.id, USER, { reason: verdict === "accepted" ? `${LEARN_ACCEPTED} by the person: its review checklist line was written to config.local.json` : `${LEARN_REJECTED} by the person` });
+  }
+  /**
+   * #514a: the same recurrence path for recurring UNMET CRITERIA. A criterion id that reviews keep naming unmet on the same profile and class, on at least
+   * `threshold` tasks that are at least two separate pieces of work (`workUnits`), files one backlog card for a person to review, with the `profile_overrides`
+   * fragment as text. Nothing is applied. A PII task and a withheld or private-turn review are never evidence and never named; the card carries ids and counts only.
+   */
+  private proposeCriterionCandidates(task: Task, by: PeerId, withheld: boolean): void {
+    if (withheld || this.isPii(task) || this.d.privateTurn?.(by) || !task.history.at(-1)?.unmetCriteria?.length) return;
+    const rows = this.d.board.list();
+    const keys = new Set(rows.filter(row => row.class === "plan" && row.history[0]?.by === HUB)
+      .flatMap(row => row.detail?.split("\n").filter(line => line.startsWith("Criterion candidate key: ")) ?? []));
+    // Only the rows that may count: candidateTextAllowed refuses a PII row and one whose text the screen refuses, so those are evidence of nothing.
+    const eligible = rows.filter(row => this.candidateTextAllowed(`${row.profile ?? ""} ${row.profileClass ?? ""} ${row.class}`, row));
+    const named = new Set(task.history.at(-1)!.unmetCriteria);
+    const created: number[] = [];
+    // No await separates the durable dedupe read from creation; concurrent verdicts see the first card.
+    const groups = groupUnmetCriteria(eligible, { windowMs: LEARNING_DEFAULTS.windowMs, now: Date.now() });
+    const unitsOf = (group: CriterionGroup) => this.workUnits(eligible.filter(row => group.tasks.includes(row.id)));
+    for (const group of selectGroups(groups, { named, threshold: LEARNING_DEFAULTS.threshold, max: LEARNING_DEFAULTS.maxGroups, has: g => keys.has(criterionKey(g)), units: unitsOf })) {
+      const card = candidateCard(group, Math.round(LEARNING_DEFAULTS.windowMs / 86_400_000), unitsOf(group));
+      const draft = { title: card.title, detail: card.detail, refs: { paths: ["docs/profiles.md"] } };
+      const signals = this.signalsFor(draft);
+      if (this.isPii({ signals }) || !this.candidateTextAllowed(`${card.title}\n${card.detail}`)) continue;
+      const proposal = this.d.board.propose(HUB, { ...draft, class: "plan", backlog: true, signals });
+      this.incomingBacklog.add(proposal.id); keys.add(criterionKey(group)); created.push(proposal.id);
+    }
+    for (const id of created) this.releaseNotice(`task #${id}: recurring unmet criterion candidate proposed in the backlog`);
+  }
   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();
@@ -698,7 +846,14 @@ export class Tasks {
 
   publicView(task: Task, fullHistory = false): Record<string, unknown> {
     const { title, detail, history, external, cancelled, codeSymbols, ...taskRest } = task;
-    const rest = { ...taskRest, ...(history.some(h => h.by === USER && h.planDeparture) ? { planDepartureAccepted: true } : {}) };
+    const plannerBinding = history.findLast(h => h.planner === task.planner && h.plannerReason !== undefined);
+    const ownerBinding = history.findLast(h => h.owner === task.owner && ["assigned", "reassigned", "escalated", "backlog pulled"].includes(h.event));
+    const reviewerBinding = history.findLast(h => ["assigned", "reassigned", "escalated", "done", "reviewer changed", "reviewer unavailable"].includes(h.event));
+    const rest = { ...taskRest,
+      ...(plannerBinding?.plannerReason && ["rotation", "named", "kept", "none"].includes(plannerBinding.plannerReason) ? { plannerReason: plannerBinding.plannerReason } : {}),
+      ...(ownerBinding?.reason && TASK_MOVE_REASONS.includes(ownerBinding.reason) ? { ownerReason: ownerBinding.reason === "manual" && ownerBinding.event === "reassigned" && ownerBinding.by !== HUB ? "named" : ownerBinding.reason } : {}),
+      ...(reviewerBinding?.reviewerReason && ["rotation", "implementer skip", "unavailable skip", "same-family fallback"].includes(reviewerBinding.reviewerReason) ? { reviewerReason: reviewerBinding.reviewerReason } : reviewerBinding?.event === "reviewer changed" && reviewerBinding.reason === "manual" ? { reviewerReason: "named" } : {}),
+      ...(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;
@@ -723,6 +878,7 @@ export class Tasks {
       ...(h.unmetCriteria?.length ? { unmetCriteria: h.unmetCriteria } : {}),
       ...(h.deliverables?.length ? { deliverables: publicDeliverables(h.deliverables, this.nameable) } : {}),
       ...(h.reviewBlocked ? { reviewBlocked: true } : {}),
+      ...(h.queueReviewHeld ? { queueReviewHeld: 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) } : {}) } } : {}),
       ...(h.reason && TASK_MOVE_REASONS.includes(h.reason) ? { reason: h.reason } : {}),
@@ -757,14 +913,15 @@ export class Tasks {
   /** Decayed failure weights of the peers demoted for a class: failures count half after a day (issue #36). */
   demoted(cls: TaskClass, now = Date.now()): Record<PeerId, number> {
     const sums = new Map<PeerId, { bad: number; good: number }>();
+    const halfLifeH = this.d.demotionHalfLifeH?.(), halfLifeMs = halfLifeH === undefined ? DEMOTION_HALF_LIFE_MS : halfLifeH * 3_600_000, demoteAt = this.d.demoteAt?.() ?? DEMOTE_AT;
     for (const o of this.d.board.outcomes(cls, now - OUTCOMES_KEPT_MS)) {
-      const w = 0.5 ** ((now - o.at) / DEMOTION_HALF_LIFE_MS);
+      const w = 0.5 ** ((now - o.at) / halfLifeMs);
       const s = sums.get(o.peer) ?? { bad: 0, good: 0 };
       if (o.ok) s.good += w;
       else s.bad += w;
       sums.set(o.peer, s);
     }
-    return Object.fromEntries([...sums].filter(([, s]) => s.bad >= DEMOTE_AT && s.bad > s.good).map(([p, s]) => [p, s.bad]));
+    return Object.fromEntries([...sums].filter(([, s]) => s.bad >= demoteAt && s.bad > s.good).map(([p, s]) => [p, s.bad]));
   }
 
   /** How each reviewer's reviews of each implementer's work in a class held up (issue #35). */
@@ -801,20 +958,57 @@ export class Tasks {
   }
 
   /** Workload is board/queue data only: wip() never calls health() or weights(). */
-  private instanceRouting(): InstanceRoutingOptions {
+  private instanceRouting(ownerIsolation?: Readonly<Record<string, boolean>>): InstanceRoutingOptions {
     const instances = this.d.instances?.();
     if (!instances || !Object.keys(instances).length) return { adapterCatalog: this.d.adapterCatalog };
     const peers = [...new Set([...(this.d.adapterCatalog?.definitions ?? ADAPTERS).map(adapter => adapter.kind), ...Object.keys(instances), ...this.d.bus.peers.keys()])];
-    return { adapterCatalog: this.d.adapterCatalog, instances, ownerIsolation: this.d.ownerIsolation?.() ?? {}, wip: Object.fromEntries(peers.map(peer => [peer, this.wip(peer)])), load: Object.fromEntries(peers.map(peer => [peer, this.d.bus.queued(peer)])) };
+    return { adapterCatalog: this.d.adapterCatalog, instances, ownerIsolation: ownerIsolation ?? this.d.ownerIsolation?.() ?? {}, wip: Object.fromEntries(peers.map(peer => [peer, this.wip(peer)])), load: Object.fromEntries(peers.map(peer => [peer, this.d.bus.queued(peer)])) };
+  }
+
+  private queuePolicy(): QueueBackpressurePolicy | undefined {
+    const policy = queueBackpressurePolicy(this.d.queueBackpressure?.());
+    return policy.max_queued > 0 || policy.max_oldest_s > 0 ? policy : undefined;
+  }
+
+  /** Admission is pending metadata only; an unavailable read never invents an empty/fresh queue. */
+  private queueRouting(peers: readonly PeerId[], policy = this.queuePolicy()): Pick<InstanceRoutingOptions, "queues" | "queueBackpressure"> & { now?: number } {
+    if (!policy) return {};
+    const queues = Object.fromEntries([...new Set(peers)].map(peer => {
+      let value: QueuePressure;
+      try { value = this.d.bus.assignmentQueue(peer); } catch { value = { queued: NaN }; }
+      return [peer, value];
+    }));
+    return { queueBackpressure: policy, queues, now: this.d.now?.() ?? Date.now() };
+  }
+
+  private contextRouting(): Pick<InstanceRoutingOptions, "contextAdmission"> & { now?: number } {
+    const admission = this.d.contextAdmission?.();
+    if (!admission || !Number.isFinite(admission.policy.max_used) || admission.policy.max_used <= 0 || admission.policy.max_used > 1) return {};
+    return { contextAdmission: admission, now: this.d.now?.() ?? Date.now() };
+  }
+
+  /** Public ids/counts/reasons only; no board history, pending envelope body or task text is read. */
+  queuePressureStatus(peers: readonly string[]): QueueBackpressureStatus | undefined {
+    const policy = this.queuePolicy();
+    if (!policy) return undefined;
+    const all = [...new Set(peers)].filter(peer => /^[a-z][a-z0-9-]{0,31}$/.test(peer));
+    const bounded = all.slice(0, 4096), input = this.queueRouting(bounded, policy), now = input.now!;
+    const rows = Object.fromEntries(bounded.map(peer => {
+      const value = peerEntry(input.queues, peer), refusal = queueBackpressure(peer, policy, value, now);
+      const queued = value && Number.isSafeInteger(value.queued) && value.queued >= 0 ? value.queued : null;
+      const at = queued !== null && queued > 0 && typeof value?.oldestQueuedAt === "number" && Number.isSafeInteger(value.oldestQueuedAt) && value.oldestQueuedAt >= 0 && value.oldestQueuedAt <= now ? value.oldestQueuedAt : null;
+      return [peer, { queued, oldestQueuedAt: at, oldestAgeMs: at === null ? null : now - at, blocked: refusal !== undefined, ...(refusal ? { code: refusal.code, reason: refusal.reason } : {}) }];
+    }));
+    return { policy, peers: rows, ...(all.length > bounded.length ? { truncated: true as const } : {}) };
   }
 
   /** Peer health and roles the daemon feeds routing (issues #89, #90, #92): failing peers are skipped, held queues explained. */
-  private health() {
+  private health(ownerIsolation?: Readonly<Record<string, boolean>>) {
     const failing = this.d.failing?.();
     const held = this.d.held?.();
-    const workload = this.instanceRouting();
+    const workload = this.instanceRouting(ownerIsolation);
     const peers = workload.instances ? [...new Set([...(this.d.adapterCatalog?.definitions ?? ADAPTERS).map(adapter => adapter.kind), ...Object.keys(workload.instances), ...this.d.bus.peers.keys()])] : (this.d.adapterCatalog?.definitions ?? ADAPTERS).map(adapter => adapter.kind);
-    return { ...workload, reviewPool: { pool: this.d.review?.pool ?? DEFAULT_REVIEW_POOL, rerotate: this.d.review?.rerotate, required: this.d.review?.pool !== undefined, ...(this.d.review?.same_family === "never" ? { sameFamily: "never" as const } : {}) }, ...(this.d.capabilities ? { capabilities: this.d.capabilities(), repository: this.d.repository } : {}), pullOnly: [...this.d.bus.peers.values()].filter(peer => (this.d.adapterCatalog?.definitionOf ?? definitionOf)(peer.id, workload.instances)?.attach?.pullOnlyForms?.length && peer.pullOnly).map(peer => peer.id), offRoster: peers.filter(peer => !this.d.bus.isRostered(peer)), ...(failing ? { failing } : {}), ...(held ? { held } : {}), ...(this.d.roles ? { roles: this.d.roles } : {}) };
+    return { ...workload, ...this.contextRouting(), ...this.queueRouting([...new Set([...peers, ...this.d.bus.peers.keys()])]), reviewPool: { pool: this.d.review?.pool ?? DEFAULT_REVIEW_POOL, rerotate: this.d.review?.rerotate, required: this.d.review?.pool !== undefined, ...(this.d.review?.same_family === "never" ? { sameFamily: "never" as const } : {}) }, ...(this.d.capabilities ? { capabilities: this.d.capabilities(), repository: this.d.repository } : {}), pullOnly: [...this.d.bus.peers.values()].filter(peer => (this.d.adapterCatalog?.definitionOf ?? definitionOf)(peer.id, workload.instances)?.attach?.pullOnlyForms?.length && peer.pullOnly).map(peer => peer.id), offRoster: peers.filter(peer => !this.d.bus.isRostered(peer)), ...(failing ? { failing } : {}), ...(held ? { held } : {}), ...(this.d.roles ? { roles: this.d.roles } : {}) };
   }
 
   private reviewHead(task: Task): string | undefined { return task.refs.commit ?? task.sdlc?.head ?? task.sdlc?.localHead; }
@@ -834,21 +1028,30 @@ export class Tasks {
   private poolReview(task: Task, refs?: TaskRefs): Assignment | undefined {
     if (this.manuallyNamedReviewer(task) || this.isPii(task) || task.class === "review") return undefined;
     const draft = { ...task, refs: { ...task.refs, ...cleanRefs(refs) } };
-    const selection = assign(draft, this.states(), this.d.routing(), { ...this.weights(task.class, draft), candidates: [], ...(task.owner ? { notReviewer: task.owner } : {}) });
-    return selection.reviewSelection ? selection : undefined;
+    const weights = this.weights(task.class, draft);
+    const selection = assign(draft, this.states(), this.d.routing(), { ...weights, candidates: [], ...(task.owner ? { notReviewer: task.owner } : {}) });
+    const heldSelection = task.reviewer === USER && task.history[this.reviewRequestRevision(task) - 1]?.queueReviewHeld === true;
+    const previous = task.reviewer && task.reviewer !== USER ? assign(draft, this.states(), this.d.routing(), { ...weights, candidates: [], namedReviewer: task.reviewer, ...(task.owner ? { notReviewer: task.owner } : {}) }) : undefined;
+    const queueRefused = previous?.refusals?.some(row => row.role === "reviewer" && row.peer === task.reviewer && isQueuePressureCode(row.code));
+    const newlyBlocked = selection.reviewBlocked && selection.refusals?.some(row => row.role === "reviewer" && isQueuePressureCode(row.code));
+    return selection.reviewSelection || queueRefused || newlyBlocked || heldSelection ? selection : undefined;
   }
 
-  private reviewMetadata(assignment?: Assignment): ReviewerHistory {
+  private reviewMetadata(assignment?: Assignment, task?: Task): ReviewerHistory {
     const choice = assignment?.reviewSelection;
     const family = choice && assignment?.plannerFallback && assignment.reviewer ? (this.d.adapterCatalog?.familyOf ?? familyOf)(assignment.reviewer, this.d.instances?.()) : choice?.family;
     const reason = choice && assignment?.plannerFallback
       ? assignment.sameFamilyFallback ? "same-family fallback" as const : "unavailable skip" as const
       : choice?.reason;
-    return { ...(family ? { reviewerFamily: family } : {}), ...(reason ? { reviewerReason: reason } : {}), ...(assignment?.reviewBlocked ? { reviewBlocked: true } : {}) };
+    const queueReviewHeld = task !== undefined && !this.isPii(task) && assignment?.reviewer === USER && assignment.reviewBlocked === true
+      && assignment.refusals?.some(row => row.role === "reviewer" && isQueuePressureCode(row.code));
+    const queueReviewBinding = task ? this.queueReviewBinding(task) : undefined;
+    return { ...(family ? { reviewerFamily: family } : {}), ...(reason ? { reviewerReason: reason } : {}), ...(assignment?.reviewBlocked ? { reviewBlocked: true } : {}), ...(queueReviewHeld ? { queueReviewHeld: true as const, ...(queueReviewBinding !== undefined ? { queueReviewBinding } : {}) } : {}) };
   }
 
   /** Capability admission precedes explicit assignments/reservations, independent of readiness or transient peer health. */
   private requireCapabilities(task: Parameters<typeof assign>[0], peer: PeerId, role: Exclude<TaskAssignmentRole, "planner"> = "owner", preEffect = true): void {
+    requireLocalTaskPeer(peer);
     const instances = this.d.instances?.(), adapter = (this.d.adapterCatalog?.definitionOf ?? definitionOf)(peer, instances);
     const declaredExtra = !!adapter && adapter.kind !== peer;
     if ((!this.d.capabilities || this.isPii(task)) && !declaredExtra) return;
@@ -865,13 +1068,14 @@ export class Tasks {
    * Selection stays in assign(); task bindings only keep that selection while the holder remains eligible.
    */
   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();
+    return Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("planner") && this.d.bus.isRostered(peer)).map(([peer]) => peer).sort();
   }
 
-  private weights(cls: TaskClass, task?: Task) {
+  private weights(cls: TaskClass, task?: Task, projectedHealth?: ReturnType<Tasks["health"]>) {
     const now = Date.now();
     const quota = this.d.quota?.();
-    return { ...this.health(), planners: this.plannerHolders(), ...(task ? { reviewPool: this.reviewPoolOptions(task), ...(task.planner ? { keptPlanner: task.planner } : {}) } : {}), now, demoted: this.demoted(cls, now), reviews: this.reviewRecord(cls), ...(quota ? { quota } : {}), ...(this.d.review?.adaptive ? { adaptive: { min: this.d.review.min_reviews } } : {}) };
+    const health = projectedHealth ?? this.health(), clock = health.now ?? now;
+    return { ...health, ...(task && this.hasPersonReservation(task) && task.reserved ? { queueReservedHold: task.reserved } : {}), planners: this.plannerHolders(), ...(task ? { reviewPool: this.reviewPoolOptions(task), ...(task.planner ? { keptPlanner: task.planner } : {}) } : {}), now: clock, demoted: this.demoted(cls, clock), reviews: this.reviewRecord(cls), ...(quota ? { quota } : {}), ...(this.d.review?.adaptive ? { adaptive: { min: this.d.review.min_reviews } } : {}) };
   }
 
   /**
@@ -929,6 +1133,8 @@ export class Tasks {
       peers,
       observations: Object.fromEntries(peers.map((p) => [p, this.splitObservations(task.class, p, task.id)])),
       units: [unit, unit],
+      ...(this.d.splitMinObservations ? { minObservations: this.d.splitMinObservations() } : {}),
+      ...(this.d.splitMaxFailureShare ? { maxFailureShare: this.d.splitMaxFailureShare() } : {}),
       profiles: Object.fromEntries(peers.map((p) => [p, this.d.splitProfile?.(p)])),
       backlog: Object.fromEntries(peers.map((p) => [p, open.filter((t) => t.owner === p).length])),
       // Busy is taking the task in question only in the turn that task started (an owner goes busy as its task is
@@ -946,11 +1152,12 @@ export class Tasks {
   private contradict(failed: Task): void {
     if (this.isPii(failed)) return; // its places are left out everywhere else too
     const now = Date.now();
+    const contradictionDays = this.d.contradictionWindowDays?.(), contradictionWindowMs = contradictionDays === undefined ? CONTRADICTION_WINDOW_MS : contradictionDays * 86_400_000;
     const mine = this.places(failed);
     for (const t of this.d.board.list("approved")) {
       if (t.id === failed.id || !t.owner || this.isPii(t)) continue;
       const approval = [...t.history].reverse().find((h) => h.event === "approved");
-      if (!approval || now - approval.at > CONTRADICTION_WINDOW_MS || approval.by === USER) continue;
+      if (!approval || now - approval.at > contradictionWindowMs || approval.by === USER) continue;
       const theirs = this.places(t);
       // Blame needs the same file or symbol: a directory or `.` would contradict every approval under it. Older rows
       // were stored as written, so both sides are compared in one spelling.
@@ -968,12 +1175,13 @@ export class Tasks {
 
   /** A removed/off-roster binding falls back to legacy holders; a busy, paused or offline holder keeps authority. */
   taskPlanner(task: Pick<Task, "planner">): PeerId[] {
-    const holders = Object.keys(this.d.roles ?? {}).filter(peer => this.d.roles?.[peer]?.includes("planner")).sort();
+    const holders = Object.keys(this.d.roles ?? {}).filter(peer => !isRemotePeerId(peer) && this.d.roles?.[peer]?.includes("planner")).sort();
     return task.planner && holders.includes(task.planner) && this.d.bus.isRostered(task.planner) ? [task.planner] : holders;
   }
 
   /** Current planner rulings amend review context, never person-only plan-departure acceptance. */
   plannerRulings(task: Task, recipient: PeerId): { historyIndex: number; by: PeerId; at: number; note: string }[] {
+    requireLocalTaskPeer(recipient);
     if (this.isPii(task)) return [];
     const boundary = task.history.findLastIndex(entry => entry.event === "accepted" || entry.event === "claimed");
     if (boundary < 0) return [];
@@ -991,13 +1199,15 @@ export class Tasks {
   }
 
   private planningAuthority(by: PeerId, task?: Pick<Task, "planner">): void {
+    requireLocalTaskPeer(by);
     if (by !== USER && (!this.d.roles?.[by]?.includes("planner") || task !== undefined && !this.taskPlanner(task).includes(by))) throw new PreEffectToolRefusal(`planning requires a person or configured planner role${task ? "; only the task's effective planner may act" : ""}`);
   }
 
   /** #812 AC5: a peer holding the configured planner role. The conductor's task reads accept it; it grants no write. */
-  isConfiguredPlanner(peer: PeerId): boolean { return peer !== USER && peer !== HUB && !!this.d.roles?.[peer]?.includes("planner"); }
+  isConfiguredPlanner(peer: PeerId): boolean { return !isRemotePeerId(peer) && peer !== USER && peer !== HUB && !!this.d.roles?.[peer]?.includes("planner"); }
 
   private plannerWriteAuthority(by: PeerId, task?: Pick<Task, "planner">): void {
+    requireLocalTaskPeer(by);
     if (by !== USER && this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("planner writes are unavailable during a private turn");
     this.planningAuthority(by, task);
   }
@@ -1063,6 +1273,7 @@ export class Tasks {
 
   /** Host-observed task branch/root binding (#845), never a tool-call branch claim or an execution grant. */
   bindShellBranch(peer: PeerId, id: number, binding: TaskShellBinding & { worktree: string }, current: () => boolean): boolean {
+    requireLocalTaskPeer(peer);
     try {
       if (!Number.isSafeInteger(id) || id < 1 || !taskShellBindingValid(binding) || !this.publicMetadataText(binding.branch)
         || !current() || this.d.privateTurn?.(peer)) return false;
@@ -1143,7 +1354,7 @@ export class Tasks {
   /** The top card explicitly reserved for `peer` that this planner may pull now; the notice and the opt-in pull read the same rule. `pullable` keeps the staged backlog cards only. */
   private topReservedReady(peer: PeerId, planner?: PeerId, pullable = false): Task | undefined {
     return this.d.board.list().filter(card => (pullable ? card.state === "backlog" : ["backlog", "proposed"].includes(card.state)) && !card.owner && card.reserved === peer
-      && (planner === undefined || this.taskPlanner(card).includes(planner)) && !(pullable && this.isPii(card)) && !card.pinned && taskCanPlan(card) && !this.waitsFor(card).length && !this.excluded(card).includes(peer)
+      && (planner === undefined || this.taskPlanner(card).includes(planner)) && !(pullable && this.isPii(card)) && !card.pinned && !card.draft && taskCanPlan(card) && !this.waitsFor(card).length && !this.excluded(card).includes(peer)
       && (card.release == null || ["planning", "active"].includes(this.d.board.release(card.release)?.state ?? ""))).sort(this.readyOrder)[0];
   }
 
@@ -1207,6 +1418,7 @@ export class Tasks {
   plannerRefusal(task: Task): string {
     const parts: string[] = [];
     const excluded = [...new Set(this.excluded(task))];
+    const pressure = this.queueRouting(Object.keys(this.states()));
     if (excluded.length) parts.push(`${excluded.join(", ")} declined or was escalated away from this task for good; only a person's ahub task assign lifts that`);
     for (const peer of Object.keys(this.states())) {
       if (excluded.includes(peer)) continue;
@@ -1214,14 +1426,16 @@ export class Tasks {
       if (wip >= limit) parts.push(`${peer} WIP full (${wip}/${limit}); no eligible planner WIP capacity`);
       else if (queue.heldBy) parts.push(`${peer} has a held queue (a delivery is held; resolve it with ahub queue list)`);
       else if (queue.needsReview > 0) parts.push(`${peer} has ${queue.needsReview} delivery(ies) in needs_review`);
+      const refusal = queueBackpressure(peer, pressure.queueBackpressure, peerEntry(pressure.queues, peer), pressure.now ?? NaN);
+      if (refusal) parts.push(`${peer} ${refusal.reason}`);
     }
     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, routing: Routing = this.d.routing()): Assignment {
+  private plannerAssignment(task: Task, reservedOnly = false, routing: Routing = this.d.routing(), queueOverride?: "owner", projectedHealth?: ReturnType<Tasks["health"]>): 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, 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) });
+    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, projectedHealth), ...(queueOverride ? { queueOverride, contextOverride: true } : {}) });
   }
 
   async pullPlanned(by: PeerId, input: { id: number; revision: number; reason: string }, opts: { onBehalfOf?: PeerId; guard?: () => void } = {}): Promise<Task> {
@@ -1229,13 +1443,18 @@ export class Tasks {
     // #785 P1c: `by` is the actor the history records; the hub's opt-in auto pull names the planner it acts for, and that planner's authority is what is checked.
     if (opts.onBehalfOf !== undefined && by !== HUB) throw new PreEffectToolRefusal("only the hub pulls on a planner's behalf");
     const planner = opts.onBehalfOf ?? by;
+    let queueAssignment: { current: () => void } | undefined;
     // `opts.guard` (the auto pull's own admission, #785 P1c) throws a PreEffectToolRefusal once the pull is no longer wanted; it runs wherever authority is rechecked, so it
     // also runs after the awaited PII screen and right before the assignment write, where a setting turned off or a recovery that began meanwhile must still stop it.
-    const authorized = () => { this.planningAuthority(planner); opts.guard?.(); };
+    const authorized = () => { this.planningAuthority(planner); opts.guard?.(); queueAssignment?.current(); };
     authorized();
     if (!Number.isSafeInteger(input.id) || input.id <= 0 || !Number.isSafeInteger(input.revision) || input.revision < 0 || typeof input.reason !== "string" || !input.reason.trim() || input.reason.length > 1000) throw new PreEffectToolRefusal("planner pull needs an id, revision and bounded reason");
+    queueAssignment = by !== HUB && opts.onBehalfOf === undefined && this.d.board.get(input.id)?.reserved
+      ? this.explicitQueueAssignment(by, "owner", true) : undefined;
+    queueAssignment?.current();
     const validate = () => {
       const task = this.d.board.get(input.id);
+      if (task?.draft) throw new PreEffectToolRefusal(`task #${task.id} is an intake draft; the person approves it first`);
       if (!task || (task.planningRevision ?? 0) !== input.revision || task.state !== "backlog" || task.owner || !taskCanPlan(task) || task.pinned) throw new PreEffectToolRefusal("planner pull changed, pinned or already started");
       this.planningAuthority(planner, task);
       const release = task.release == null ? undefined : this.d.board.release(task.release);
@@ -1253,7 +1472,7 @@ export class Tasks {
         })) throw new PreEffectToolRefusal("a person's P0 backlog order is retained");
       }
       if (task.reserved && this.excluded(task).includes(task.reserved)) throw new PreEffectToolRefusal(this.plannerRefusal(task));
-      const assignment = this.plannerAssignment(task, !!task.reserved);
+      const assignment = this.plannerAssignment(task, !!task.reserved, this.d.routing(), queueAssignment ? "owner" : undefined);
       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}`);
@@ -1264,7 +1483,7 @@ export class Tasks {
     authorized();
     const current = validate();
     if (current.task.reserved) {
-      return this.assignOwner(current.task, by, { candidates: [current.owner], namedOwner: current.owner, planner: true, refuseNamed: "pre",
+      return this.assignOwner(current.task, by, { candidates: [current.owner], namedOwner: current.owner, planner: true, refuseNamed: "pre", ...(queueAssignment ? { queueOverride: "owner" as const, current: queueAssignment.current } : {}),
         plannerPull: { revision: input.revision, note: input.reason.trim(), withheld, guard: () => {
           authorized();
           const checked = validate();
@@ -1286,7 +1505,7 @@ export class Tasks {
     const pending = this.plannerBacklog.get(peer) ?? new Set<number>();
     for (const id of ids) {
       const task = this.d.board.get(id);
-      if (task?.state === "backlog" && this.taskPlanner(task).includes(peer)) pending.add(id);
+      if (task?.state === "backlog" && !task.draft && this.taskPlanner(task).includes(peer)) pending.add(id);
     }
     if (pending.size) this.plannerBacklog.set(peer, pending);
   }
@@ -1327,11 +1546,13 @@ export class Tasks {
       scan.revision = revision;
     }
     const now = this.d.now?.() ?? Date.now();
+    const configuredFyiMin = this.d.groomFyiWindowMin?.();
+    const fyiWindowMs = configuredFyiMin === undefined ? GROOM_FYI_WINDOW_MS : configuredFyiMin * 60_000;
     for (const peer of planners) {
       const told = scan.sent.get(peer), pending = scan.pending.get(peer);
       const review = told === undefined || pending?.review === true;
       if (!review && !pending?.other) continue;
-      if (!review && now - told!.fyiAt < GROOM_FYI_WINDOW_MS) { scan.pending.delete(peer); continue; }
+      if (!review && now - told!.fyiAt < fyiWindowMs) { scan.pending.delete(peer); continue; }
       this.releaseNotice(`could not notify planner ${peer} about grooming`, () => {
         if (review) this.sendGroomNotice(peer, revision);
         else this.d.bus.publish(newEnvelope(HUB, `${GROOM_NOTICE_PREFIX} (revision ${revision}): state moves, reviews or assignments only. No plan review is needed.`, { to: [peer], kind: "task", priority: "fyi" }));
@@ -1351,7 +1572,7 @@ export class Tasks {
 
   /** One bounded ids-only batch per attached planner; failed or evicted copies stay pending. */
   flushPlannerNotices(): number {
-    const configured = Object.entries(this.d.roles ?? {}).filter(([, roles]) => roles.includes("planner")).map(([peer]) => peer);
+    const configured = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && roles.includes("planner")).map(([peer]) => peer);
     for (const peer of this.knownPlanners) if (!configured.includes(peer)) {
       this.knownPlanners.delete(peer); this.plannerBacklog.delete(peer); this.plannerBlockedQueue.delete(peer);
       this.groomScan.pending.delete(peer); this.groomScan.sent.delete(peer);
@@ -1542,7 +1763,7 @@ export class Tasks {
   }
 
   async importGitHub(by: PeerId, input: GitHubImportSelection, run?: SdlcGh): Promise<{ imported: number[]; existing: number[]; partial: boolean; complete: boolean; unconfirmed?: true }> {
-    if (by !== USER) throw new PreEffectToolRefusal("GitHub import is a person console command");
+    if (!this.personOrConductor(by)) throw new PreEffectToolRefusal("GitHub import is a person console command");
     const deadline = performance.now() + 20_000;
     const page = await readGitHubImport(input, run ?? ((args, timeout, _cwd, bound) => sdlcGh(args, timeout, this.d.cwd, bound)));
     const imported: number[] = [], existing: number[] = [];
@@ -1554,7 +1775,7 @@ export class Tasks {
         if (prior) { existing.push(prior.id); continue; }
         const classes = profileData(this.d.profileData ?? this.d.profile ?? "dev").classes;
         const cls = Object.keys(classes).find(name => classes[name] === "implement") ?? Object.keys(classes)[0];
-        const task = await this.propose(USER, { title: issue.title, detail: issue.detail, class: cls, backlog: true }, issue.source, () => { created = true; });
+        const task = await this.propose(by, { title: issue.title, detail: issue.detail, class: cls, backlog: true }, issue.source, () => { created = true; });
         (created ? imported : existing).push(task.id);
         if (performance.now() >= deadline) return { imported, existing, partial: true, complete: false };
       } catch {
@@ -1570,8 +1791,10 @@ export class Tasks {
     return { imported, existing, partial: page.partial, complete: !page.partial };
   }
 
-  async splitBacklog(by: PeerId, input: { id: number; revision: number; parts: unknown; reason: string }): Promise<{ parent: Task; children: Task[] }> {
-    this.planningAuthority(by);
+  async splitBacklog(by: PeerId, input: { id: number; revision: number; parts: unknown; reason: string }, opts: { intake?: true } = {}): Promise<{ parent: Task; children: Task[] }> {
+    // #334: the hub writes an intake draft's own model split; no other write by the hub passes as a planner.
+    const authority = (task?: Pick<Task, "planner">) => { if (!(opts.intake && by === HUB)) this.planningAuthority(by, task); };
+    authority();
     const { id, revision } = input;
     if (!Number.isSafeInteger(id) || id <= 0 || !Number.isSafeInteger(revision) || revision < 0 || typeof input.reason !== "string" || !input.reason.trim() || input.reason.length > 1000) throw new PreEffectToolRefusal("split needs an id, revision and bounded reason");
     const reason = input.reason.trim();
@@ -1584,7 +1807,9 @@ export class Tasks {
       if (!parent || parent.state !== "backlog" || parent.owner || taskHasStarted(parent) || (parent.planningRevision ?? 0) !== revision || by !== USER && parent.pinned) throw new PreEffectToolRefusal("split changed, pinned or already started");
       const release = parent.release == null ? undefined : this.d.board.release(parent.release);
       if (parent.release != null && (!release || ["shipped", "dropped"].includes(release.state) || by !== USER && release.state === "frozen")) throw new PreEffectToolRefusal("split release scope is frozen or final");
-      this.planningAuthority(by, parent);
+      authority(parent);
+      // #334: the hub writes a split only into a draft that is still a draft. Both validations run (before and after the awaited screen), and the board asks again in its transaction.
+      if (opts.intake && by === HUB && !parent.draft) throw new PreEffectToolRefusal("split changed, pinned or already started");
       const profile = parent.profile ?? "dev";
       const drafts = rows.map((part, index) => {
         if (!part || typeof part !== "object" || Array.isArray(part) || Object.keys(part).some(key => !["title", "detail", "class", "refs", "plan", "after", "afterParts"].includes(key)) || typeof part.title !== "string" || !part.title.trim() || part.title.length > 300 || part.detail !== undefined && (typeof part.detail !== "string" || part.detail.length > 8000) || part.class !== undefined && typeof part.class !== "string") throw new PreEffectToolRefusal("invalid split part");
@@ -1619,7 +1844,7 @@ export class Tasks {
     let screened: Awaited<typeof attempt>;
     try { screened = await Promise.race([attempt, new Promise<never>((_, reject) => { deadline = setTimeout(() => reject(new PreEffectToolRefusal("split screening request deadline exceeded")), BACKLOG_SPLIT_SCREEN_TIMEOUT_MS); })]); }
     finally { if (deadline !== undefined) clearTimeout(deadline); }
-    this.planningAuthority(by); // #455: a person may have moved the planner while the screen ran
+    authority(); // #455: a person may have moved the planner while the screen ran
     const [screenedVerdicts, withheld] = screened, current = validate();
     const finalSignals = current.drafts.map(part => this.signalsFor({ ...part, detail: [part.detail, planText(part.plan)].join("\n") }));
     const deterministicPrivate = finalSignals.map((signals, index) => initialPrivate[index] || this.isPii({ signals }));
@@ -1627,6 +1852,8 @@ export class Tasks {
     const inherited = current.drafts.map((_part, index) => (initialParentPrivate || this.isPii(current.parent)) && !deterministicPrivate[index]);
     const drafts = current.drafts.map((part, index) => ({ ...part, ...(screening ? { screeningNote: inherited[index] ? "pii: inherited" : this.screenNote(verdicts[index]) } : {}), signals: [...new Set([...initialPrivacy[index]!, ...initialParentPrivacy, ...finalSignals[index]!, ...current.parent.signals.filter(signal => ["pii", "pii_path", "urgent"].includes(signal)), ...(verdicts[index] && verdicts[index]!.label !== "clear" ? ["pii"] : [])])] }));
     for (const draft of drafts) this.warmRepository(draft);
+    // #334: the hub's intake split is only for a draft; the board asks for it again inside its transaction (a flag set for exactly this write, never left on).
+    this.d.board.requireDraftForNextSplit = opts.intake === true && by === HUB;
     const result = this.d.board.splitBacklog(id, by, revision, drafts, reason, withheld || initialReasonPrivate || this.isPii(current.parent) || !this.nameable(reason));
     if (this.d.coordination) {
       const mode = this.d.coordination();
@@ -1640,6 +1867,92 @@ export class Tasks {
     return result;
   }
 
+  /**
+   * The draft and every open draft card split from it, at any depth, parent first. A planner may split an intake child again before approval, and
+   * the grandchildren inherit the mark, so the walk follows `deps` through draft cards only: a dependency on ordinary work is never followed.
+   */
+  private intakeFamily(id: number): Task[] {
+    const root = this.d.board.get(id);
+    if (!root || !root.draft || root.state !== "backlog") throw new PreEffectToolRefusal(`task #${id} is not an open intake draft`);
+    const family: Task[] = [root], seen = new Set([root.id]);
+    for (let next = 0; next < family.length; next++) {
+      for (const dep of family[next]!.deps ?? []) {
+        if (seen.has(dep)) continue;
+        const child = this.d.board.get(dep);
+        if (!child || !child.draft || child.state !== "backlog") continue;
+        seen.add(dep); family.push(child);
+      }
+    }
+    return family;
+  }
+
+  /**
+   * #334 (#511a): the person's request becomes one parent draft, a backlog card that nothing offers or pulls. A planner is asked to split it with
+   * `hub_backlog_split`; with none, or for a request that is PII, the hub's model proposes the split and the hub writes it. A split that does not
+   * validate leaves the draft whole, with the reason on its history.
+   */
+  async intake(by: PeerId, input: { text: unknown; sources?: unknown }): Promise<{ draft: Task; children: Task[]; split: "planner" | "hub" | "unsplit"; reason?: string }> {
+    if (by !== USER) throw new PreEffectToolRefusal("intake is a console command");
+    const text = typeof input.text === "string" ? input.text.trim() : "";
+    if (!text || text.length > INTAKE_MAX_TEXT) throw new PreEffectToolRefusal(`intake needs a request of 1 to ${INTAKE_MAX_TEXT} characters`);
+    const given = input.sources ?? [];
+    if (!Array.isArray(given) || given.length > INTAKE_MAX_SOURCES || given.some(id => typeof id !== "string" || !SOURCE_ID.test(id)) || new Set(given).size !== given.length) throw new PreEffectToolRefusal(`sources: at most ${INTAKE_MAX_SOURCES} distinct src:<16 hex> ids`);
+    const sources = given as string[];
+    for (const id of sources) if (!this.d.intake?.sourceKnown(id)) throw new PreEffectToolRefusal(`unknown source ${id}; register it with ahub source add`);
+    const title = `Intake: ${text.split("\n")[0]!.replace(/\s+/g, " ").trim().slice(0, 80)}`;
+    let draft = await this.propose(USER, { title, detail: intakeDetail(text, sources), class: "plan", backlog: true, draft: true });
+    this.incomingBacklog.delete(draft.id);
+    const priv = this.isPii(draft);
+    const planner = priv ? undefined : this.taskPlanner(draft).find(peer => this.d.bus.isRostered(peer) && this.d.bus.peers.has(peer) && this.d.bus.stateOf(peer) !== "offline");
+    if (planner) {
+      const body = plannerRequestBody({ id: draft.id, revision: draft.planningRevision ?? 0, text: parseIntakeDetail(String(this.publicView(draft).detail)).text, sources });
+      try {
+        if (this.d.bus.publish(newEnvelope(HUB, sanitize(body), { to: [planner], kind: "task", refs: { task: String(draft.id), taskRecipient: "planner" } })).includes(planner)) return { draft, children: [], split: "planner" };
+      } catch { /* the planner is not reachable: the hub model takes it */ }
+    }
+    return { ...(await this.intakeByHub(draft, text, sources, priv)), draft: this.d.board.get(draft.id) ?? draft };
+  }
+
+  /** The hub model's split of a draft, validated against the profile's `hub_backlog_split` parts schema and written through `splitBacklog`. */
+  private async intakeByHub(draft: Task, text: string, sources: string[], priv: boolean): Promise<{ children: Task[]; split: "hub" | "unsplit"; reason?: string }> {
+    const unsplit = (reason: string) => { this.d.board.update(draft.id, HUB, "intake unsplit", {}, reason); return { children: [], split: "unsplit" as const, reason }; };
+    if (!this.d.intake) return unsplit("no planner is attached and the hub has no model for a split");
+    // A request that is PII goes only to a model reached on campus; without one it stays whole for the person.
+    if (priv && !(await this.d.triage?.onCampus().catch(() => false))) return unsplit("the request is PII and no on-prem model was reached");
+    let raw: string | undefined;
+    try { raw = await this.d.intake.split(intakeSystemPrompt(Object.keys(profileData(this.d.profileData ?? this.d.profile ?? "dev").classes), this.d.intake.partsSchema()), intakeUserMessage(text, sources), { campusOnly: priv }); } catch { raw = undefined; }
+    const parsed = parseIntakeSplit(raw, this.d.intake.partsSchema(), sources);
+    if ("error" in parsed) return unsplit(parsed.error);
+    const current = this.d.board.get(draft.id);
+    if (!current || !current.draft || current.state !== "backlog") return unsplit("the draft changed while the model answered");
+    try {
+      const result = await this.splitBacklog(HUB, { id: draft.id, revision: current.planningRevision ?? 0, parts: parsed.parts, reason: "intake: split by the hub model" }, { intake: true });
+      return { children: result.children, split: "hub" };
+    } catch (error) { return unsplit(`the split was refused: ${error instanceof PreEffectToolRefusal ? sanitize(error.message).slice(0, 200) : "the board refused it"}`); }
+  }
+
+  /** #334: the person approves a draft; it and its children leave draft and follow the normal backlog pull. */
+  async approveIntake(by: PeerId, id: unknown): Promise<Task[]> {
+    if (!this.personOrConductor(by)) throw new PreEffectToolRefusal("intake approval is a console command");
+    if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) throw new PreEffectToolRefusal("id must be a positive task number");
+    const family = this.intakeFamily(id);
+    let approved: Task[];
+    try { approved = this.d.board.approveDrafts(family.map(task => task.id), by, by === USER ? "intake approved by the person" : `intake approved by the conductor ${by}`); }
+    catch (error) { throw new PreEffectToolRefusal((error as Error).message); }
+    for (const task of approved) this.incomingBacklog.add(task.id);
+    this.releaseNotice(`intake draft #${id} approved: ${approved.length} backlog card${approved.length === 1 ? "" : "s"}`);
+    return approved;
+  }
+
+  /** #334: the person discards a draft; it and its children are cancelled through `cancel`. */
+  async discardIntake(by: PeerId, id: unknown): Promise<Task[]> {
+    if (by !== USER) throw new PreEffectToolRefusal("intake discard is a console command");
+    if (typeof id !== "number" || !Number.isSafeInteger(id) || id <= 0) throw new PreEffectToolRefusal("id must be a positive task number");
+    const cancelled: Task[] = [];
+    for (const task of this.intakeFamily(id)) cancelled.push(await this.cancel(task.id, USER, { reason: "intake draft discarded by the person" }));
+    return cancelled;
+  }
+
   /** Release assignment changes no execution role, dependency, reservation or state. */
   async assignRelease(by: PeerId, input: { id: number; revision: number; release: number | null; reason: string }): Promise<Task> {
     this.plannerWriteAuthority(by);
@@ -1789,12 +2102,14 @@ export class Tasks {
     return updated; // a failed readback may follow a durable release write
   }
 
-  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);
+  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; draft?: unknown; goal?: unknown }, external?: GitHubSource, created?: () => void, fence?: () => string | undefined): Promise<Task> {
+    const requestCheck = this.requestCheck(by, fence);
+    requireLocalTaskPeer(input.owner);
     external = external ? { ...external } : undefined;
-    if (external && (by !== USER || input.backlog !== true)) throw new PreEffectToolRefusal("external intake requires person-owned backlog staging");
+    if (external && (!this.personOrConductor(by) || 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");
     const backlog = input.backlog === true;
+    if (input.draft !== undefined && (input.draft !== true || !backlog || by !== USER)) throw new PreEffectToolRefusal("only the person's intake stages a backlog draft");
     const claiming = !backlog && input.owner === by;
     if (claiming) {
       this.acceptanceCapacity({ id: -1, owner: by, state: "proposed" });
@@ -1864,7 +2179,7 @@ export class Tasks {
     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 } : {}) });
+    let task = this.d.board.propose(by, { ...draft, plan, ...(external ? { external } : {}), ...(deps.length ? { deps } : {}), ...(reserved ? { reserved } : {}), signals, ...(backlog ? { backlog: true } : {}), ...(input.draft === true ? { draft: 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?.();
@@ -1934,6 +2249,7 @@ export class Tasks {
     if (!Number.isSafeInteger(n) || n <= 0) throw new PreEffectToolRefusal("id must be a positive task number");
     const task = this.d.board.get(n);
     if (!task) throw new PreEffectToolRefusal(`no task #${n}`);
+    if (pull && task.draft) throw new PreEffectToolRefusal(`task #${n} is an intake draft; approve it with ahub intake approve ${n} first`);
     if (task.state !== (pull ? "backlog" : "proposed") || task.owner) throw new PreEffectToolRefusal(`task #${n}: ${pull ? "only backlog may be pulled" : "only ownerless proposed work may return to backlog"}`);
     if (!pull && taskHasStarted(task)) throw new PreEffectToolRefusal(`task #${n}: started work cannot return to backlog`);
     const pulled = task.history.findLast(entry => entry.event === "backlog pulled" || entry.event === "backlog returned");
@@ -1977,7 +2293,8 @@ export class Tasks {
       return t.state === "proposed" && !t.owner && !t.history.some((h) => h.owner) && t.signals.includes("pii") && last.startsWith("pii: unknown") && last !== "pii: unknown, too long";
     };
     const tries = (t: Task) => this.rescreens.get(t.id) ?? 0;
-    const task = this.d.board.list("proposed").filter((t) => waiting(t) && tries(t) < RESCREEN_MAX).sort((a, b) => tries(a) - tries(b))[0];
+    const rescreenMax = this.d.rescreenMax?.() ?? RESCREEN_MAX;
+    const task = this.d.board.list("proposed").filter((t) => waiting(t) && tries(t) < rescreenMax).sort((a, b) => tries(a) - tries(b))[0];
     if (!task) return;
     this.rescreens.set(task.id, (this.rescreens.get(task.id) ?? 0) + 1);
     const text = screenText(task);
@@ -2117,6 +2434,7 @@ export class Tasks {
    * 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 {
+    requireLocalTaskPeer(to);
     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);
@@ -2124,6 +2442,7 @@ export class Tasks {
   }
 
   whileOpen(to: PeerId, task: number, body: string, states: Task["state"][] = OPEN): void {
+    requireLocalTaskPeer(to);
     const env = newEnvelope(HUB, body, { to: [to], kind: "task", refs: { task: String(task), taskRecipient: "owner" } });
     this.conditional.set(env.id, { peer: to, task, states });
     if (this.conditional.size > 1024) this.conditional.delete(this.conditional.keys().next().value as string);
@@ -2262,6 +2581,7 @@ export class Tasks {
    * Only when some other peer can take a task: with nobody to hand it to, it stays with its owner.
    */
   async releaseFromGone(peer: PeerId, minutes: number): Promise<{ id: number; title: string; to: PeerId | null }[]> {
+    requireLocalTaskPeer(peer);
     const moved: { id: number; title: string; to: PeerId | null }[] = [];
     const why = `owner ${peer} offline for ${minutes} min`;
     const ids = this.d.board.list().filter((t) => t.owner === peer && OPEN.includes(t.state)).map((t) => t.id);
@@ -2334,11 +2654,12 @@ export class Tasks {
     }
   }
 
-  /** A person's owner removal sticks until a later explicit assignment or reservation, across hub runs. */
+  /** Authorized manual owner removal sticks until a later explicit assignment/reservation, across hub runs. */
   private personUnassigned(task: Task): boolean {
-    const removed = task.history.findLastIndex((h) => h.event === "unassigned" && h.by === USER);
+    const manual = (h: HistoryEntry) => h.by === USER || h.conductorManual === true;
+    const removed = task.history.findLastIndex((h) => h.event === "unassigned" && manual(h));
     if (removed < 0) return false;
-    return !task.history.slice(removed + 1).some((h) => h.by === USER && ["assigned", "reassigned", "escalated", "reserved", "backlog pulled"].includes(h.event));
+    return !task.history.slice(removed + 1).some((h) => manual(h) && ["assigned", "reassigned", "escalated", "reserved", "backlog pulled"].includes(h.event));
   }
 
   /**
@@ -2390,7 +2711,7 @@ 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: { current?: () => void; 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> {
+  private async assignOwner(task: Task, by: PeerId, opts: { current?: () => void; conductorManual?: true; queueOverride?: "owner"; 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> {
     opts.current?.();
     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;
@@ -2420,7 +2741,9 @@ 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(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 } : {}) });
+    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 } : {}), // A self-claim hands over no envelope; reviewer admission remains automatic.
+      contextOverride: !!(opts.queueOverride || opts.claim),
+      ...(opts.queueOverride || opts.claim ? { queueOverride: opts.queueOverride ?? "owner" as const } : {}) });
 
     if (waits.length) {
       if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull waits for dependency approval");
@@ -2434,14 +2757,18 @@ export class Tasks {
         const why = a.refusals?.find(row => row.role === "owner" && row.peer === opts.namedOwner)?.reason ?? "not eligible";
         throw new (opts.refuseNamed === "pre" ? PreEffectToolRefusal : Error)(`cannot assign task #${task.id} to ${opts.namedOwner}: ${why}${/offline|not attached/.test(why) ? "; assign again once it is attached" : ""}`);
       }
-      if (!task.owner && task.state === "proposed") this.reportStall(task, this.ownerStallCause(task, a));
       this.releaseNotice(opts.roster
         ? `task ${this.publicTitle(task)}: ${task.owner} is off roster and no peer can take it; it stays with ${task.owner} in ${task.state}; assign with: ahub task assign ${task.id} <peer>`
         : `task ${this.publicTitle(task)}: no peer can take it (${a.trace.filter((l) => l.includes("skipped")).length} skipped); assign with: ahub task assign ${task.id} <peer>`);
       // Only a decline takes the task away from its owner; a failed console assign or escalation leaves it where it was.
       if (opts.clearOnFail && task.owner) {
         this.cohorts.leave(task.id);
-        return this.d.board.update(task.id, by, "unassigned", { owner: null });
+        task = this.d.board.update(task.id, by, "unassigned", { owner: null });
+      }
+      if (!task.owner && task.state === "proposed") {
+        const cause = this.ownerStallCause(task, a, !opts.claim);
+        // A named proposal remains bound to that target when pressure clears.
+        this.reportStall(task, cause.kind === "no-eligible-peer" && isQueuePressureCode(cause.code) && opts.namedOwner ? { ...cause, peer: opts.namedOwner } : cause);
       }
       return task;
     }
@@ -2452,11 +2779,12 @@ export class Tasks {
     opts.plannerPull?.guard();
     const assignmentNote = this.assignmentNote(`${opts.note ?? `to ${a.owner}`}${passed}`, a);
     const binding = this.plannerBinding(task, a, !!opts.plannerPull);
-    const assignmentExtra = { ...this.reviewMetadata(a), ...(binding ? { plannerReason: binding.plannerReason } : {}), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}) };
+    const assignmentExtra = { ...this.reviewMetadata(a, task), ...(binding ? { plannerReason: binding.plannerReason } : {}), ...(profile ? { profile } : {}), ...(opts.reason ? { reason: opts.reason } : {}), ...(lasting ? { from: task.owner! } : {}), ...(opts.conductorManual ? { conductorManual: true as const } : {}) };
     opts.current?.();
     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, binding)
       : this.d.board.update(task.id, by, opts.event ?? "assigned", { owner: a.owner, reviewer: a.reviewer ?? null, ...(binding ? { planner: binding.planner } : {}), ...(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);
+    this.queueReviewWritten(next);
     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
@@ -2523,11 +2851,16 @@ export class Tasks {
     return next;
   }
 
-  /** Person-only advice changes never change ownership, class or authority. */
+  /** #933: the person, or the configured conductor inside an admitted operation (`TasksDeps.operational` rechecks the role). */
+  private personOrConductor(by: PeerId): boolean { return by === USER || this.d.operational?.(by) === true; }
+
+  /** Advice changes by the person or, #933, the task's own owner never change ownership, class or authority. */
   setRole(by: PeerId, id: unknown, raw: unknown): Task {
-    if (by !== USER) throw new PreEffectToolRefusal("only the person may change an existing task catalog role");
     if (raw === undefined) throw new PreEffectToolRefusal("name a catalog role id or explicit null to clear it");
     const task = this.need(id, false, true);
+    if (by !== USER && task.owner !== by) throw new PreEffectToolRefusal(`task #${task.id} is not yours: an agent changes the catalog role of its own task only`);
+    // #933: under review the role is what the reviewer reviews against; only the person changes it then.
+    if (by !== USER && task.state === "in_review") throw new PreEffectToolRefusal(`task #${task.id} is in review: only the person changes its catalog role until the verdict`);
     if (isClosedTaskState(task.state)) throw new PreEffectToolRefusal("a closed task's role is historical; propose new work instead");
     let selected;
     try { selected = taskRole(raw === null ? undefined : raw, task.class, this.d.catalog ?? loadRoleCatalog(this.d.cwd)); }
@@ -2537,7 +2870,7 @@ export class Tasks {
     for (const peer of new Set([next.owner, next.state === "in_review" ? next.reviewer : null])) {
       if (!peer || peer === USER) continue;
       this.releaseNotice(`task ${this.publicTitle(next)}: catalog role update delivery unconfirmed`, () => this.d.bus.publish(newEnvelope(HUB,
-        `Task #${next.id}: catalog role changed by the person. ${next.role ? this.roleGuidance(next, peer, peer === next.reviewer) : "Catalog guidance cleared; follow the task's existing plan and requirements."}`,
+        `Task #${next.id}: catalog role changed by ${by === USER ? "the person" : by}. ${next.role ? this.roleGuidance(next, peer, peer === next.reviewer) : "Catalog guidance cleared; follow the task's existing plan and requirements."}`,
         { to: [peer], kind: "task", refs: { task: String(next.id), taskRecipient: peer === next.reviewer ? "reviewer" : "owner" }, ...(this.isPii(next) ? { private: true } : {}) })));
     }
     return next;
@@ -2545,6 +2878,7 @@ export class Tasks {
 
   /** A self-claim has no assignment envelope; its tool result carries the same bounded guidance. */
   claimRoleGuidance(task: Task, peer: PeerId): string {
+    requireLocalTaskPeer(peer);
     return task.owner === peer && task.state === "in_progress" ? this.roleGuidance(task, peer) : "";
   }
 
@@ -2707,7 +3041,8 @@ export class Tasks {
       try { return this.d.offerRead?.(offer.peer, offer.envelopeId) !== true; } catch { return true; }
     }).map(offer => ({ ...offer }));
   }
-  stalled(): TaskStall[] {
+  /** A status-only snapshot is advisory; all effect/admission callers retain fresh health by default. */
+  stalled(projection?: { ownerIsolation: Readonly<Record<string, boolean>> }): TaskStall[] {
     const revision = this.d.board.statusRevision();
     if (this.stallCandidates?.revision !== revision) this.stallCandidates = { revision, rows: this.d.board.stalls().flatMap(stall => {
       const task = this.d.board.get(stall.task);
@@ -2717,37 +3052,213 @@ export class Tasks {
       return this.waitsFor(task).length ? [] : [{ stall, task, planned: this.plannerPullRecord(task)?.pull === true }];
     }) };
     // Eligibility inputs are live; queue journal writes alone do not re-decode board histories.
-    const key = JSON.stringify([revision, this.states(), this.d.routing(), this.health(), [...this.d.bus.peers.keys()].map(peer => {
+    const health = this.health(projection?.ownerIsolation);
+    const key = JSON.stringify([revision, this.states(), this.d.routing(), health, [...this.d.bus.peers.keys()].map(peer => {
       const queue = this.d.bus.queueSummary(peer);
       return [peer, this.wipLimit(peer), queue.heldBy, queue.needsReview];
     })]);
-    if (this.stallView?.key !== key) this.stallView = { key, stalls: this.stallCandidates.rows.filter(({ stall, task, planned }) => stall.cause.kind === "no-writes" || stall.cause.kind === "cancelled-dependency" || !(planned ? this.plannerAssignment(task, true) : assign(task, this.states(), this.d.routing(), { exclude: this.excluded(task), ...this.health() })).owner).map(({ stall }) => stall) };
+    if (this.stallView?.key !== key) this.stallView = { key, stalls: this.stallCandidates.rows.filter(({ stall, task, planned }) => stall.cause.kind === "no-writes" || stall.cause.kind === "cancelled-dependency" || !(planned ? this.plannerAssignment(task, true, this.d.routing(), undefined, health) : assign(task, this.states(), this.d.routing(), { exclude: this.excluded(task), ...this.weights(task.class, task, health), ...(stall.cause.kind === "no-eligible-peer" && isQueuePressureCode(stall.cause.code) && stall.cause.peer ? { candidates: [stall.cause.peer], namedOwner: stall.cause.peer } : {}) })).owner).map(({ stall }) => stall) };
     return structuredClone(this.stallView.stalls);
   }
+  private queuePressureKnown: boolean | undefined;
+  private queuePressureGeneration = 0;
+  private queuePressureQueued = false;
+  private queuePressureRunning = false;
+  private queuePressureDirty = false;
+  private queuePressureStopped = false;
+  private queuePressurePass?: QueuePressurePass;
+  private queuePressureContinuation?: ReturnType<typeof setImmediate>;
+
+  private markQueuePressureCandidate(): void {
+    this.queuePressureKnown = true; this.queuePressureGeneration++;
+    this.scheduleQueuePressureRecheck();
+  }
+  private queueReviewWritten(task: Task): void {
+    if (task.state === "in_review" && task.reviewer === USER && task.history.at(-1)?.queueReviewHeld) this.markQueuePressureCandidate();
+  }
+  private queuePressureAdmitted(): boolean {
+    try { return !this.queuePressureStopped && !this.d.sweepHeld?.() && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError; }
+    catch { return false; }
+  }
+  /** Run after the bus's synchronous queue checkpoint, coalescing notifications without polling. */
+  scheduleQueuePressureRecheck(): void {
+    if (this.queuePressureStopped || this.queuePressureKnown === false) return;
+    this.queuePressureDirty = true;
+    if (this.queuePressureQueued || this.queuePressureRunning || this.queuePressureContinuation) return;
+    this.queuePressureQueued = true;
+    queueMicrotask(() => {
+      this.queuePressureQueued = false;
+      if (!this.queuePressureAdmitted()) return;
+      this.queuePressureDirty = false;
+      const pass = this.queuePressurePass ??= { ownerAfter: 0, reviewAfter: 0, ownerDone: false, reviewDone: false, retained: false, generation: this.queuePressureGeneration };
+      this.queuePressureRunning = true;
+      let failed = false;
+      void this.recheckQueuePressureBatch(pass).catch(() => {
+        failed = true;
+        // A failed/unknown metadata or authority read never creates an assignment.
+        this.queuePressureKnown = true; this.queuePressurePass = undefined;
+      }).finally(() => {
+        this.queuePressureRunning = false;
+        if (!this.queuePressureAdmitted()) { this.queuePressurePass = undefined; return; }
+        if (failed) return;
+        if (this.queuePressurePass && (!pass.ownerDone || !pass.reviewDone)) {
+          this.queuePressureContinuation = setImmediate(() => { this.queuePressureContinuation = undefined; this.scheduleQueuePressureRecheck(); });
+          this.queuePressureContinuation.unref?.();
+          return;
+        }
+        this.queuePressurePass = undefined;
+        const changed = pass.generation !== this.queuePressureGeneration;
+        this.queuePressureKnown = pass.retained || changed;
+        if ((this.queuePressureDirty || changed) && this.queuePressureKnown) this.scheduleQueuePressureRecheck();
+      });
+    });
+  }
+  /** Recovery waits for queued/running host writers; a stop fences a writer already in an await. */
+  queuePressureRechecksPending = (): number => Number(this.queuePressureQueued || this.queuePressureRunning || this.queuePressureContinuation !== undefined);
+  stopQueuePressureRechecks(): void {
+    this.queuePressureStopped = true; this.queuePressureDirty = false; this.queuePressureQueued = false;
+    if (this.queuePressureContinuation) clearImmediate(this.queuePressureContinuation);
+    this.queuePressureContinuation = undefined; this.queuePressurePass = undefined;
+  }
+  private ordinaryQueueProposal(stall: TaskStall, task: Task | undefined): task is Task {
+    return !!task && task.state === "proposed" && !task.owner && !task.draft
+      && !this.waitsFor(task).length && !this.personUnassigned(task) && !this.plannerPullRecord(task)?.pull;
+  }
+  private queueReviewBinding(task: Task): string {
+    return createHash("sha256").update(JSON.stringify([this.reviewHead(task) ?? null, task.refs.repo ?? null, task.sdlc?.repo ?? null, task.sdlc?.pr ?? null])).digest("hex");
+  }
+  private queueReviewHeld(task: Task): boolean {
+    if (task.state !== "in_review" || task.reviewer !== USER || this.isPii(task) || this.manuallyNamedReviewer(task)) return false;
+    const role = task.history[this.reviewRequestRevision(task) - 1];
+    return role?.queueReviewHeld === true && role.queueReviewBinding === this.queueReviewBinding(task);
+  }
+  private async recheckQueuePressureBatch(pass: QueuePressurePass): Promise<void> {
+    if (!this.queuePressureAdmitted()) return;
+    if (!pass.ownerDone) {
+      const page = this.d.board.queuePressureStallPage(pass.ownerAfter, QUEUE_RECHECK_PAGE);
+      pass.ownerAfter = page.afterTask; pass.ownerDone = page.done;
+      for (const stall of page.rows) {
+        if (!this.queuePressureAdmitted()) return;
+        const task = this.d.board.get(stall.task);
+        if (!this.ordinaryQueueProposal(stall, task)) { this.d.board.clearStall(stall.task); continue; }
+        // A planning revision asks for fresh admission, never erases an automatic offer.
+        const namedOwner = stall.cause.peer;
+        const retry = namedOwner ? { candidates: [namedOwner], namedOwner } : {};
+        const choice = assign(task, this.states(), this.d.routing(), { exclude: this.excluded(task), waitsFor: this.waitsFor(task), ...this.weights(task.class, task), ...retry });
+        if (choice.owner) {
+          const current = () => { if (!this.queuePressureAdmitted()) throw new PreEffectToolRefusal("queue-pressure retry is no longer admitted"); };
+          try {
+            // Reserved ready work shares the existing WIP, in-flight slot and offered fences.
+            if (task.reserved) await this.offerReady(task, "queue pressure cleared", current);
+            else await this.assignOwner(task, HUB, { current, ...retry });
+          } catch (error) {
+            if (!(error instanceof AssignmentUndeliveredError) && this.queuePressureAdmitted()) pass.retained = true;
+          }
+          if (!this.queuePressureAdmitted()) return;
+        } // Pure transient eligibility reads keep the origin; only a gate that owns retries replaces it.
+        const latest = this.d.board.get(task.id);
+        if (this.ordinaryQueueProposal(stall, latest)) {
+          const origin = this.d.board.queuePressureStallPage(task.id - 1, 1).rows.find(row => row.task === task.id);
+          if (this.isHeld(latest)) this.d.board.clearStall(task.id); // WIP release owns its ready-held task now.
+          else if (origin) {
+            this.d.board.recordStall({ ...origin, replanRevision: latest.planningRevision ?? 0 });
+            pass.retained = true;
+          } else {
+            const replacing = this.d.board.stall(task.id);
+            const selected = choice.owner;
+            const refusal = replacing && selected ? replacing.cause.peer === selected ? replacing.cause.code : replacing.cause.refusals?.find(row => row.peer === selected)?.code : undefined;
+            const transient = replacing && (replacing.cause.kind === "no-eligible-peer" || replacing.cause.kind === "reservation") && replacing.cause.code !== "policy" && (refusal === "offline" || refusal === "not-attached");
+            if (transient) {
+              // The initially eligible owner vanished during admission; a policy gate never reaches this restore.
+              this.d.board.recordStall({ ...stall, replanRevision: latest.planningRevision ?? 0 });
+              pass.retained = true;
+            }
+          } // Other replacing gates keep their stall and own any later retry.
+        } else this.d.board.clearStall(task.id);
+      }
+    }
+    if (!pass.reviewDone && this.queuePressureAdmitted()) {
+      const ids = this.d.board.humanReviewPage(pass.reviewAfter, QUEUE_RECHECK_PAGE);
+      pass.reviewAfter = ids.at(-1) ?? pass.reviewAfter; pass.reviewDone = ids.length < QUEUE_RECHECK_PAGE;
+      for (const id of ids) {
+        if (!this.queuePressureAdmitted()) return;
+        const task = this.d.board.get(id);
+        if (!task || !this.queueReviewHeld(task)) continue;
+        const reviewer = await this.recheckQueueReview(task);
+        if (!this.queuePressureAdmitted()) return;
+        const latest = this.d.board.get(id);
+        if (!reviewer && latest && this.queueReviewHeld(latest)) pass.retained = true;
+      }
+    }
+  }
+  private async recheckQueueReview(before: Task): Promise<PeerId | undefined> {
+    const revision = this.reviewRequestRevision(before), head = this.reviewHead(before), owner = before.owner;
+    const valid = () => {
+      if (!this.queuePressureAdmitted()) throw new PreEffectToolRefusal("queue-pressure retry is no longer admitted");
+      const task = this.need(before.id, false, true);
+      if (!this.queueReviewHeld(task) || this.reviewRequestRevision(task) !== revision || this.reviewHead(task) !== head || task.owner !== owner) throw new PreEffectToolRefusal("queue-held review changed");
+      return task;
+    };
+    const choose = (task: Task) => assign(task, this.states(), this.d.routing(), { ...this.weights(task.class, task), candidates: [], ...(task.owner ? { notReviewer: task.owner } : {}) });
+    const initial = choose(valid());
+    if (!initial.reviewer || initial.reviewer === USER || initial.reviewBlocked) return undefined;
+    try {
+      const admission = await this.reviewRequestAdmission(before, undefined, true, before.owner ?? USER, undefined, () => { valid(); return true; });
+      const task = valid(), selection = choose(task), reviewer = selection.reviewer;
+      if (!reviewer || reviewer === USER || selection.reviewBlocked) return undefined;
+      valid();
+      const next = this.d.board.update(task.id, HUB, "reviewer changed", { reviewer }, this.assignmentNote("queue pressure cleared", selection), this.reviewMetadata(selection), task.history.length);
+      this.heldReviews.delete(next.id);
+      // The current head is unchanged; its watcher reads the live reviewer at completion.
+      this.releaseNotice(`task #${next.id}: queued review request unavailable`, () => this.sendReview(next, reviewer, "", admission));
+      return reviewer;
+    } catch { return undefined; }
+  }
+
   /** Why a proposal's named owner (a self-claim included) did not get it, from the stall its proposal recorded (#601); undefined when it did. */
   namedOwnerNote(task: Task, named: PeerId | undefined, by: PeerId): string | undefined {
+    requireLocalTaskPeer(by);
     if (!named || task.owner || task.state !== "proposed") return undefined;
     const stall = this.d.board.stalls().find(row => row.task === task.id);
     if (!stall) return undefined;
     const code = stall.cause.refusals?.find(row => row.peer === named)?.code ?? (stall.cause.peer === named ? stall.cause.code : undefined);
     return `${named} was not assigned${code ? ` (${code})` : ""}: ${stall.cause.kind}; assign it again with hub_task_assign once ${named} can take it`;
   }
-  private ownerStallCause(task: Task, admission: Assignment): TaskStall["cause"] {
+  private ownerStallCause(task: Task, admission: Assignment, automatic = true): TaskStall["cause"] {
     const refusal = admission.refusals?.find(row => row.role === "owner" && row.peer === task.reserved);
     // Persist the existing stall vocabulary; the assignment/explain keeps the precise instance/family refusal.
-    const persisted = (code: NonNullable<Assignment["refusals"]>[number]["code"]): TaskStall["cause"]["code"] => code === "instance" || code === "family" ? "policy" : code;
-    return refusal ? { kind: "reservation", peer: refusal.peer, code: persisted(refusal.code) } : { kind: "no-eligible-peer", code: "unavailable", refusals: admission.refusals?.filter(row => row.role === "owner").map(({ peer, code }) => ({ peer, code: persisted(code) })).sort((a, b) => a.peer.localeCompare(b.peer)) ?? [] };
+    const persisted = (code: NonNullable<Assignment["refusals"]>[number]["code"]): TaskStall["cause"]["code"] => code === "context-headroom" || code === "instance" || code === "family" ? "policy" : code;
+    const pressure = automatic ? admission.refusals?.find(row => row.role === "owner" && isQueuePressureCode(row.code)) : undefined;
+    return refusal && !(automatic && isQueuePressureCode(refusal.code)) ? { kind: "reservation", peer: refusal.peer, code: persisted(refusal.code) } : { kind: "no-eligible-peer", code: pressure ? persisted(pressure.code) : "unavailable", refusals: admission.refusals?.filter(row => row.role === "owner").map(({ peer, code }) => ({ peer, code: persisted(code) })).sort((a, b) => a.peer.localeCompare(b.peer)) ?? [] };
   }
   private reportStall(task: Task, cause: TaskStall["cause"], now = Date.now(), description?: string): void {
     const stall: TaskStall = { task: task.id, cause, signature: JSON.stringify(cause), replanRevision: task.planningRevision ?? 0, at: now };
     if (!this.d.board.recordStall(stall)) return;
+    if (cause.kind === "no-eligible-peer" && isQueuePressureCode(cause.code)) this.markQueuePressureCandidate();
     const text = description ?? `Task #${task.id} stalled: ${cause.kind}${cause.peer ? ` ${cause.peer}` : ""}${cause.dependency ? ` #${cause.dependency}` : ""} (${cause.code}); configure the runner or peer, ahub task assign ${task.id} <peer>, re-plan dependencies, or cancel it.`;
     this.releaseNotice(text);
     try { this.d.stallNotice?.(stall); } catch { /* advisory never changes task authority */ }
     // Advice joins the planner's next delivery; it must not manufacture a turn beside a withheld backlog batch.
     for (const peer of this.taskPlanner(task).filter(peer => this.d.bus.isRostered(peer))) this.releaseNotice(`task #${task.id}: stall notice unavailable`, () => this.d.tell?.(peer, noteLine(HUB, "finding", text)));
   }
+  /**
+   * #901: the person's verdict on one declared claim of a document plan, with the model label they say produced it. Person only (an agent's word on its own claim is no verdict, and task
+   * approval never supplies one). The claim is named by its 1-based slot in the task's current plan; its text is not stored, sent or echoed, so a PII task records the same counters and
+   * its history entry stays a stub. The entry is not a transition and moves nothing; a later verdict for the same slot supersedes the earlier one (the scorecard reads the last).
+   */
+  recordClaimVerdict(by: PeerId, id: unknown, input: unknown): Task {
+    if (by !== USER) throw new Error("only the console user may record a claim verdict");
+    if (this.d.cancellationHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) throw new Error("recovery or shutdown is holding task writes");
+    const task = this.need(id);
+    const claims = task.plan?.claims?.length ?? 0;
+    if (!claims) throw new Error(`task #${task.id} declares no plan claims: add them to its plan first`);
+    const claim = parseClaimVerdict(input, claims);
+    // Bound to the claim list it evaluated: a hash of the plan's claims (never their text), so a later replacement or reorder of the list leaves this verdict naming no claim of the new list.
+    return this.d.board.update(task.id, USER, "claim verdict", {}, undefined, { claim: { ...claim, list: claimListId(task.plan?.claims) } });  // no note: nothing a person typed beyond the closed fields is kept
+  }
+
   async cancel(id: unknown, by: PeerId, input: { reason: string; supersededBy?: string; expectedFlowRevision?: number }): Promise<Task> {
+    requireLocalTaskPeer(by);
     if (typeof input.reason !== "string" || !input.reason.trim() || Buffer.byteLength(input.reason) > 4000 || input.supersededBy !== undefined && (typeof input.supersededBy !== "string" || !input.supersededBy.trim() || Buffer.byteLength(input.supersededBy) > 1000)) throw new PreEffectToolRefusal("cancellation needs a bounded reason and supersession reference");
     const validate = () => {
       if (this.d.cancellationHeld?.() || this.d.bus.isRecoveryHeld) throw new PreEffectToolRefusal("recovery or shutdown is holding cancellation");
@@ -2795,15 +3306,21 @@ export class Tasks {
   }
 
   async releaseReady(): Promise<void> {
+    const haveQueueOrigins = this.queuePressureKnown !== false && this.d.board.queuePressureStallPage(0, 1).afterTask > 0;
     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; }
       const last = t.history.findLast(entry => !QUIET_EVENTS.has(entry.event))?.event, planned = this.plannerPullRecord(t)?.pull === true;
       if (this.personUnassigned(t) || this.offered.has(t.id) || this.waitsFor(t).length) continue;
-      const admission = planned ? this.plannerAssignment(t, true) : assign(t, this.states(), this.d.routing(), { exclude: this.excluded(t), ...this.health() });
+      if (haveQueueOrigins) {
+        const origin = this.d.board.queuePressureStallPage(t.id - 1, 1).rows.find(row => row.task === t.id);
+        if (origin && this.ordinaryQueueProposal(origin, t)) { this.scheduleQueuePressureRecheck(); continue; }
+      }
+      const admission = planned ? this.plannerAssignment(t, true) : assign(t, this.states(), this.d.routing(), { exclude: this.excluded(t), ...this.weights(t.class, t) });
       if (!admission.owner) {
-        this.reportStall(t, this.ownerStallCause(t, admission));
+        // A diagnostic legacy pass is not evidence that an automatic proposal was attempted.
+        this.reportStall(t, this.ownerStallCause(t, admission, this.hasPersonReservation(t)));
         continue;
       }
       this.d.board.clearStall(t.id);
@@ -2815,7 +3332,8 @@ 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> {
+  private async offerReady(stale: Task, why: string, current?: () => void): Promise<void> {
+    current?.();
     let offering = false, undelivered: AssignmentUndeliveredError | undefined, slot: PeerId | undefined;
     try {
       const t = this.d.board.get(stale.id);
@@ -2832,7 +3350,7 @@ export class Tasks {
       offering = true;
       const ready = t.history.at(-1)?.event === "ready" ? t : this.d.board.update(t.id, HUB, "ready", {}, why);
       this.releaseNotice(`task ${this.publicTitle(ready)} is ready: what it waited for is approved`);
-      await this.assignOwner(ready, HUB, planned ? { candidates: [selected!], namedOwner: selected!, planner: true } : {});
+      await this.assignOwner(ready, HUB, { current, ...(planned ? { candidates: [selected!], namedOwner: selected!, planner: true } : {}) });
     } catch (e) {
       // A saved move whose delivery failed is not "could not be assigned" (#297); the console notice was printed
       // where the error was thrown. The offer stays consumed by the error's own evidence, without the readback.
@@ -2852,6 +3370,7 @@ export class Tasks {
   }
 
   private mine(task: Task, by: PeerId, role: "owner" | "reviewer", preEffect = false): void {
+    requireLocalTaskPeer(by);
     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`);
   }
 
@@ -2874,6 +3393,31 @@ export class Tasks {
     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;
   }
 
+  /**
+   * #798 D1: a declared path (refs, plan paths, the file part of a section anchor) inside a git submodule of this project: snapshots, facts, overlap and undo do not observe
+   * inside a submodule. A notice, never a refusal: the task stays valid. Advice only, so a PII task gets none, a path whose name matches a PII pattern is not named, and a
+   * task bound to another repository is judged against that one's layout, which this project's `.gitmodules` does not describe (its scope is not the project's).
+   */
+  submoduleNotice(task: Task): string | undefined {
+    if (this.isPii(task)) return undefined;
+    let submodules: string[];
+    try { submodules = this.d.submodules?.() ?? []; } catch { return undefined; }
+    if (!submodules.length) return undefined;
+    if (this.repositories.scope(task.refs) !== this.repositories.project) return undefined;
+    const declared = [...(task.refs.paths ?? []), ...(task.plan?.paths ?? []), ...(task.plan?.sections ?? []).map(anchor => anchor.split("#")[0]!).filter(Boolean)];
+    const inside = new Set<string>();
+    for (const path of declared) {
+      let local: string;
+      try { local = this.projectPath(path); } catch { continue; }
+      if (local === ".." || local.startsWith("../") || isAbsolute(local)) continue;
+      const hit = submodules.find(sub => local === sub || local.startsWith(`${sub}/`));
+      if (hit) inside.add(hit);
+    }
+    const named = [...inside].filter(this.nameable).sort();
+    if (!named.length) return inside.size ? "inside a submodule (path withheld, it matches a PII pattern): facts, overlap and undo do not observe it" : undefined;
+    return named.map(path => `inside submodule ${path}: facts, overlap and undo do not observe it`).join("\n");
+  }
+
   /** #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;
@@ -3028,7 +3572,53 @@ export class Tasks {
     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: the merge-time readback the guarded merge recorded on each merged task's receipt (host-written, never a tool input), and the two series that are not made of tasks.
+    const mergedAt: Record<number, number> = {}, ciReruns: Record<number, number | null> = {}, ciRuns: Record<number, number | null> = {}, reviews: Record<number, number | null> = {};
+    for (const task of rows) {
+      const merge = task.sdlc?.merge;
+      if (!visibleIds.has(task.id) || merge?.state !== "merged") continue;
+      const cost = cleanMergeCost(merge.cost);
+      const at = cost?.mergedAt ?? (Number.isSafeInteger(merge.at) ? merge.at : null);
+      if (at !== null) mergedAt[task.id] = at;
+      if (cost) { ciReruns[task.id] = cost.ciReruns; ciRuns[task.id] = cost.ciRuns; reviews[task.id] = cost.reviews; }
+    }
+    return sdlcMetrics(tasks, { ...(cutoff !== undefined ? { since: cutoff } : {}), ...(this.d.sdlc?.config().bands ? { bands: this.d.sdlc.config().bands } : {}), stalls, mergedAt, ciReruns, ciRuns, reviews, external: this.externalSeries(), ...(merged ?? {}) });
+  }
+
+  /** #481 S7: one point per shipped release (1 for a hotfix, 0 otherwise; a release with no recorded train is skipped, never a 0) and one per recorded security scan whose total is known. */
+  private externalSeries(): Partial<Record<BandMetric, SeriesPoint[]>> {
+    const rows = this.d.board.list(), privateRelease = (id: number) => rows.some(task => task.release === id && this.isPii(task));
+    const hotfix = this.d.board.releases().filter(release => release.state === "shipped" && release.shippedAt !== null && release.train?.history.length && !privateRelease(release.id))
+      .sort((a, b) => a.shippedAt! - b.shippedAt! || a.id - b.id).map(release => ({ value: release.train!.hotfix ? 1 : 0, task: release.id }));
+    const config = this.d.sdlc?.config().securityScan, repo = config?.repo ?? this.d.repository;
+    // A band needs `window` baseline points plus the newest one, and the episode walk looks back up to EPISODE_LOOKBACK more, so the series loads that many known
+    // totals (unknown ones are filtered in SQL, never counted against the limit). The board caps one read at 1000 rows.
+    const need = (this.d.sdlc?.config().bands?.security_open_alerts?.window ?? DEFAULT_BAND.window) + EPISODE_LOOKBACK + 2;
+    const scans = config && typeof repo === "string" ? this.d.board.securityScans(repo, config.sources.join(","), need, true).map(scan => ({ value: scan.total!, task: scan.id })) : [];
+    return { hotfix_rate: hotfix, security_open_alerts: scans };
+  }
+
+  /**
+   * #481 S7: the scheduled security-scan baseline. Reads the open-alert counts GitHub already holds (`security-baseline.ts`), records one row per interval and then runs the
+   * same band path as every other metric, so a breach is one deduplicated card. Held like every host writer; a private repository identity, a mode off, no `[security_scan]`
+   * table and a scan that is not yet due all do nothing. A source GitHub will not read (not enabled, not permitted) records an unknown total, never zero. Returns the scan id.
+   */
+  async runSecurityScan(now = Date.now()): Promise<number | undefined> {
+    const config = this.d.sdlc?.config(), scan = config?.securityScan;
+    if (!config || config.mode === "off" || !scan) return undefined;
+    const repo = scan.repo ?? this.d.repository;
+    if (typeof repo !== "string" || !this.nameable(repo)) return undefined;
+    const held = () => !!this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || !!this.d.bus.storageError;
+    if (held()) return undefined;
+    const sources = scan.sources.join(","), last = this.d.board.securityScans(repo, sources, 1).at(-1);
+    if (last && now - last.at < scan.everyH * 3_600_000) return undefined;
+    const read = await readSecurityScan(repo, scan.sources, this.d.sdlc?.gh ?? sdlcGh);
+    const after = this.d.sdlc?.config();
+    // The read awaited: the lifecycle, the schedule or a hold may have changed meanwhile, so nothing is written from a stale decision.
+    if (!read || held() || !after || after.mode === "off" || JSON.stringify(after.securityScan) !== JSON.stringify(scan)) return undefined;
+    const id = this.d.board.recordSecurityScan({ repo, sources, counts: read.counts as Record<string, number | null>, total: read.total });
+    this.proposeFromBands();
+    return id;
   }
 
   /**
@@ -3047,10 +3637,14 @@ export class Tasks {
   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]) : "" };
+    // The release and scan series do not move the task board's revision, so what they last held is part of the signature: a shipped release or a new scan row is a reason to run again.
+    const external = configured ? this.externalSeries() : {};
+    return { ready: configured && !this.d.sweepHeld?.() && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError,
+      signature: configured ? JSON.stringify([config!.mode, config!.bands, config!.securityScan ?? null, external.hotfix_rate?.length ?? 0, external.security_open_alerts?.at(-1)?.task ?? 0]) : "" };
   }
 
   proposeFromBands(by: PeerId = HUB): number[] {
+    requireLocalTaskPeer(by);
     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 [];
@@ -3064,22 +3658,24 @@ export class Tasks {
     // 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[] = [];
+    // Fixed words and a number: a release or a security scan is named by its id, a task by `task #id`.
+    const subjectText = (band: BandResult, id: number) => band.subject === "release" ? `release #${id}` : band.subject === "scan" ? `security scan #${id}` : `task #${id}`;
     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}`);
+        if (!open.has(band.metric) && this.d.board.recordBandNotice(marker)) this.releaseNotice(`sdlc band: ${band.metric} is ${band.reason}; last value ${band.last} on ${subjectText(band, 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 evidence = `metric ${band.metric}; newest value ${band.last} on ${subjectText(band, band.lastTask)}; episode began at ${subjectText(band, band.episode)}; baseline mean ${band.mean}, deviation ${band.sd} over ${band.baseline} ${band.subject === "release" ? "releases" : band.subject === "scan" ? "scans" : "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."
+        ? `Read-only triage for the planner: inspect the recent ${band.subject === "release" ? "releases" : band.subject === "scan" ? "security scans" : "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);
@@ -3091,6 +3687,167 @@ export class Tasks {
     return created;
   }
 
+  /** The open task each schedule made: a hub-written card (first history entry by the hub) whose detail starts with the schedule marker and that is not closed. */
+  openScheduled(): Map<string, number> {
+    const open = new Map<string, number>();
+    for (const row of this.d.board.list()) {
+      const key = row.history[0]?.by === HUB && !isClosedTaskState(row.state) ? scheduleKeyOf(row.detail) : undefined;
+      if (key !== undefined && !open.has(key)) open.set(key, row.id);
+    }
+    return open;
+  }
+
+  /** Whether a scheduled run may write now: the same holds as every host writer (stopping or recovering, held by the daemon, a storage error). */
+  schedulesHeld(): boolean { return !!this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || !!this.d.bus.storageError; }
+
+  private schedulesRunning = false;
+  /** 1 while a schedules pass is running (its PII screen and triage are awaited), so a recovery commit waits for it like it waits for `checksPending` and `autoPullsPending`: a run mid-admission would write after the commit's digest. */
+  schedulesPending = (): number => (this.schedulesRunning ? 1 : 0);
+  /**
+   * One due schedule's run: the hold, the open-task rule and the proposal, shared by the timer and `ahub schedule run`, so a manual run can never do what a due
+   * one may not. `propose` asks the fence again right before its board write, so a run admitted and then overtaken by a hold writes nothing and counts as a skip.
+   */
+  private async runSchedule(store: ScheduleStore, entry: ScheduleEntry, now: number, extraHold: () => boolean, manual = false): Promise<ScheduleRunResult> {
+    const hold = () => this.schedulesHeld() || extraHold() ? "the hub is held" : undefined;
+    // A skipped tick is counted for the timer only: a person's refused run is not a missed period, so it never feeds the coalescing count.
+    const skip = () => { if (!manual) store.skipped(entry.id); };
+    if (hold()) { skip(); return { id: entry.id, outcome: "held" }; }
+    const open = this.openScheduled().get(entry.id);
+    if (open !== undefined) { skip(); return { id: entry.id, outcome: "waiting", task: open }; }
+    // The PII screen and triage are awaited inside `propose`, and a hold can begin during them (shutdown, recovery, a storage error). `propose` asks this fence
+    // again right before its board write, so a run that was admitted and then overtaken by a hold writes nothing and counts as a skip, like one held at the start.
+    // The same fence also reads the schedule's pause generation (#335): a person who paused or resumed it after this run was admitted has changed what should happen,
+    // so the run writes nothing. A timer run that finds it paused or resumed meanwhile is dropped (the next pass decides); a person's own run never races its own command.
+    const admitted = store.epoch(entry.id);
+    let overtaken = false, changed = false;
+    const fence = () => {
+      const reason = hold(); if (reason) overtaken = true;
+      if (!reason && !manual && store.epoch(entry.id) !== admitted) { changed = true; return "the schedule was paused or resumed"; }
+      return reason;
+    };
+    try {
+      const task = await this.propose(HUB, { title: entry.title, detail: scheduledDetail(entry), class: entry.class, backlog: entry.queue === "backlog",
+        ...(entry.owner ? { owner: entry.owner } : {}) }, undefined, undefined, fence);
+      store.ran(entry.id, now, task.id);
+      return { id: entry.id, outcome: "ran", task: task.id };
+    } catch (error) {
+      if (changed) return { id: entry.id, outcome: "changed" };
+      if (overtaken) { try { skip(); } catch { /* the store closed with the hub */ } return { id: entry.id, outcome: "held" }; }
+      store.failed(entry.id, sanitize((error as Error).message));
+      return { id: entry.id, outcome: "failed" };
+    }
+  }
+
+  /**
+   * #512a: one pass over the machine-local schedules. A schedule is due once `every` has passed since its period began (first sight, then its last run).
+   * A due schedule proposes at most one task per pass, through `propose` like any proposal (the PII screen, triage, routing and notices all apply), and none
+   * while the task its previous run made is still open. While the hub is held the whole pass skips and every due schedule counts the skip, so a long hold
+   * ends in one run per schedule, never a burst. A run restarts the period at `now`: nothing a restart or a hold missed is replayed. Returns what each due schedule did.
+   */
+  async proposeFromSchedules(store: ScheduleStore, entries: readonly ScheduleEntry[], now: number, extraHold: () => boolean = () => false): Promise<ScheduleRunResult[]> {
+    if (this.schedulesRunning) return [];
+    this.schedulesRunning = true;
+    const out: ScheduleRunResult[] = [];
+    try {
+      store.prune(entries.map(entry => entry.id));
+      for (const entry of entries) {
+        const row = store.ensure(entry.id, now);
+        if (row.paused) continue; // #335: a person's pause is neither a run nor a skipped tick
+        if (now < row.anchor + parseEvery(entry.every)) continue;
+        out.push(await this.runSchedule(store, entry, now, extraHold));
+      }
+    } finally { this.schedulesRunning = false; }
+    return out;
+  }
+
+  /**
+   * #335: `ahub schedule run <id>`. The person runs one configured schedule now, whatever its period says. It takes the same pass guard as the timer (so it never
+   * overlaps one), the same hold, open-task and `propose` path (`runSchedule`), and restarts that schedule's period on success like a due run. A paused schedule
+   * runs too: a pause stops the timer, not the person. Only the person may.
+   */
+  async runScheduleNow(by: PeerId, store: ScheduleStore, entries: readonly ScheduleEntry[], id: unknown, now: number, extraHold: () => boolean = () => false): Promise<ScheduleRunResult & { reason?: string }> {
+    if (!this.personOrConductor(by)) throw new PreEffectToolRefusal("schedule run is a console command");
+    const entry = typeof id === "string" ? entries.find(candidate => candidate.id === id) : undefined;
+    if (!entry) throw new PreEffectToolRefusal(`no schedule ${typeof id === "string" ? JSON.stringify(id.slice(0, 64)) : "named"}; ahub schedule list shows the configured ones`);
+    if (this.schedulesRunning) throw new PreEffectToolRefusal("a schedules pass is running; try again in a moment");
+    this.schedulesRunning = true;
+    try {
+      store.ensure(entry.id, now);
+      // #933: the board-write fence asks the hold again after the PII screen, so a conductor whose role or connection ended meanwhile writes nothing.
+      const result = await this.runSchedule(store, entry, now, () => extraHold() || !this.personOrConductor(by), true);
+      const reason = result.outcome === "failed" ? store.get(entry.id)?.last_error ?? undefined : undefined;
+      return reason ? { ...result, reason } : result;
+    } finally { this.schedulesRunning = false; }
+  }
+
+  /** #335: pause or resume one configured schedule. Only the person may; resuming starts a fresh period, so a pause is never replayed as a run. */
+  setSchedulePaused(by: PeerId, store: ScheduleStore, entries: readonly ScheduleEntry[], id: unknown, paused: boolean, now: number): void {
+    if (!this.personOrConductor(by)) throw new PreEffectToolRefusal(`schedule ${paused ? "pause" : "resume"} is a console command`);
+    const entry = typeof id === "string" ? entries.find(candidate => candidate.id === id) : undefined;
+    if (!entry) throw new PreEffectToolRefusal(`no schedule ${typeof id === "string" ? JSON.stringify(id.slice(0, 64)) : "named"}; ahub schedule list shows the configured ones`);
+    store.setPaused(entry.id, paused, now);
+  }
+
+  /**
+   * #336 (#512c): one pass over the machine-local folder triggers, on the schedules timer. Each trigger's folder is read once (never watched). The first poll of a trigger
+   * records what is already there and proposes nothing, so adding a trigger to a full inbox does not flood the board; after that a file the trigger has not recorded (by
+   * real path and content hash) is registered as a source through `register` and proposes ONE task through `propose` as the hub, which names the source id and never the
+   * file's name or path. A rename or a touch keeps the hash and proposes nothing. While the hub is held nothing is read or recorded, so the files wait for the next poll.
+   * A file is recorded only after its task exists, so a failure or a hold between the two leaves it to be tried again (a crash in that window can repeat one task; it
+   * never loses a file). At most MAX_NEW_PER_POLL files per trigger per pass.
+   */
+  async runFolderTriggers(store: FolderStorePort, entries: readonly FolderEntry[], scan: (entry: FolderEntry) => FolderScan, register: (file: ScannedFile) => { id: string; private: boolean }, now: number, extraHold: () => boolean = () => false): Promise<FolderRunResult[]> {
+    if (this.schedulesRunning) return [];
+    this.schedulesRunning = true;
+    const out: FolderRunResult[] = [];
+    try {
+      store.prune(entries.map(entry => entry.id));
+      for (const entry of entries) out.push(await this.runFolderTrigger(store, entry, scan, register, now, extraHold));
+    } finally { this.schedulesRunning = false; }
+    return out;
+  }
+
+  private async runFolderTrigger(store: FolderStorePort, entry: FolderEntry, scanOf: (entry: FolderEntry) => FolderScan, register: (file: ScannedFile) => { id: string; private: boolean }, now: number, extraHold: () => boolean): Promise<FolderRunResult> {
+    const hold = () => this.schedulesHeld() || extraHold() ? "the hub is held" : undefined;
+    if (hold()) return { id: entry.id, outcome: "held", tasks: [], files: 0 };
+    const scan = scanOf(entry);
+    // A refused folder never starts the trigger: when it becomes readable, what is in it then is the baseline, not news.
+    if (scan.refused) { store.polled(entry.id, now, scan.refused); return { id: entry.id, outcome: "refused", tasks: [], files: 0, reason: scan.refused }; }
+    // The baseline is every file already in the folder when the trigger starts. A folder too big to hash in one poll (the scan's budget, `truncated`) is baselined over
+    // several polls: each records what it read and proposes nothing, and the poll that reaches the end of the folder completes it. Only then is a file news.
+    if (!store.baselined(entry.id)) {
+      store.begin(entry.id, now);
+      for (const file of scan.files) if (!file.seen) store.record(entry.id, file, null, now);
+      if (!scan.truncated) store.markBaselined(entry.id, now); else store.polled(entry.id, now);
+      return { id: entry.id, outcome: "baseline", tasks: [], files: scan.files.length };
+    }
+    // A file the trigger already knows by content (a rename, a touch, a copy) proposes nothing, but its new path, size and mtime are recorded, so the next scan finds it with
+    // `known` instead of hashing it again: otherwise such files would spend the hash budget on every poll and starve a genuinely new one behind them.
+    for (const file of scan.files) if (!file.seen && !store.isNew(entry.id, file.sha256)) store.observe(entry.id, file, now);
+    // `isNew` is asked again for each file below, not only here: two files with the same new bytes can arrive before one poll, and the first one's record must suppress the second.
+    const fresh = scan.files.filter(file => !file.seen && store.isNew(entry.id, file.sha256));
+    const tasks: number[] = [];
+    let error: string | undefined;
+    for (const file of fresh) {
+      if (tasks.length >= MAX_NEW_PER_POLL || hold()) break;
+      if (!store.isNew(entry.id, file.sha256)) { store.observe(entry.id, file, now); continue; } // a duplicate found inside the loop: recorded, never a second task
+      let overtaken = false;
+      const fence = () => { const reason = hold(); if (reason) overtaken = true; return reason; };
+      try {
+        const source = register(file);
+        const task = await this.propose(HUB, { title: entry.title, detail: folderDetail(entry, source.id), class: entry.class, backlog: entry.queue === "backlog", ...(entry.owner ? { owner: entry.owner } : {}) }, undefined, undefined, fence);
+        store.record(entry.id, file, task.id, now);
+        tasks.push(task.id);
+      } catch (caught) {
+        if (overtaken) break;
+        error = sanitize((caught as Error).message);
+        break; // the next poll tries this file again; later files wait behind it so order is kept
+      }
+    }
+    store.polled(entry.id, now, error);
+    return { id: entry.id, outcome: error ? "failed" : tasks.length ? "ran" : "none", tasks, files: fresh.length, ...(scan.truncated ? { more: true as const } : {}), ...(error ? { reason: error } : {}) };
+  }
+
   /** 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 = () => {
@@ -3130,7 +3887,7 @@ export class Tasks {
     const scoped = current.filter(task => visiblePrs.has(task.sdlc!.pr!) && !this.isPii(task));
     const scopedIds = new Set(scoped.map(task => task.id));
     const stalls = { noWrites: this.stalled().filter(stall => stall.cause.kind === "no-writes" && scopedIds.has(stall.task)).length, doneWithoutWrites: scoped.filter(task => task.history.findLast(entry => entry.event === "done")?.noWrites).length };
-    return { ...report, stalls, truncated: report.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}), bands: "S7 pending" };
+    return { ...report, stalls, truncated: report.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}), bands: "see ahub sdlc metrics" };
   }
 
   async planReviewGap(task: Task): Promise<string | undefined> {
@@ -3205,18 +3962,21 @@ export class Tasks {
    * 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> {
+    const requestCheck = this.requestCheck(by);
     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);
+    requestCheck();
     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 {
+    requireLocalTaskPeer(by);
     const task = this.need(id, false, true);
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
     const next = sdlcReceipt(input, task.sdlc, config, VERSION);
@@ -3257,6 +4017,25 @@ export class Tasks {
     return this.d.board.list().map(t => ({ id: t.id, after: t.deps ?? [], private: this.isPii(t), receipt: t.sdlc, phase: this.isPii(t) ? undefined : this.workflowView(t), findings: this.isPii(t) ? undefined : this.reviewFindingSets(t), plan: config.mode === "off" || this.isPii(t) ? undefined : { paths: this.planPaths(t), revision: t.history.findLast(h => h.planRevision)?.planRevision?.revision ?? 0, fingerprint: planFingerprint(t.plan ?? {}), accepted: this.validPlanDepartures(t) } }));
   }
 
+  /**
+   * The board links one `readMergeQueue` read used for a subject (#491): the subject, the holders of the PRs in the open set it read (repository names compare without
+   * case, as the queue does), and the tasks those holders and the subject depend on. Nothing else reaches the queue: a proposal, a plan or finding elsewhere, a holder
+   * of a closed or merged PR that nobody depends on, or a receipt in another repository cannot change what it saw. Pass the queue the decision read: its rows are the
+   * open set. Without one (the read failed) every link counts.
+   */
+  private queueLinks(links: DeliveryTask[], subject: DeliveryTask, queue: MergeQueue | undefined): DeliveryTask[] {
+    if (!queue) return links;
+    const repo = subject.receipt?.repo?.toLowerCase(), open = new Set(queue.rows.map(row => row.pr));
+    // The subject's own dependencies are also reached as a holder of its open PR; naming them here keeps the fence right if that PR were ever absent from the rows.
+    const used = new Set<number>([subject.id, ...subject.after]);
+    for (const link of links) {
+      if (repo === undefined || link.receipt?.repo?.toLowerCase() !== repo || link.receipt.pr === undefined || !open.has(link.receipt.pr)) continue;
+      used.add(link.id);
+      for (const id of link.after) used.add(id);
+    }
+    return links.filter(link => used.has(link.id));
+  }
+
   async deliveryQueue(repo: string) {
     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 })));
@@ -3289,8 +4068,9 @@ export class Tasks {
   private readonly mergesInFlight = new Set<number>();
   /** #786: who may ask for a guarded merge. The hub's own approval trigger acts as HUB; a peer must be the one configured conductor. */
   private mergeAuthority(by: PeerId): boolean {
+    if (isRemotePeerId(by)) return false;
     if (by === USER || by === HUB) return true;
-    const holders = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
+    const holders = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
     return holders.length === 1 && holders[0] === by;
   }
   /**
@@ -3321,14 +4101,15 @@ export class Tasks {
     this.mergesInFlight.add(task.id);
     try {
       const links = this.deliveryLinks(config), subject = links.find(link => link.id === task.id)!;
-      const queueIdentity = workflowHash({ config, links });
       const outcome = await guardedMerge({ mode, subject, state: task.state, taskState: n => this.d.board.get(n)?.state, config, tasks: links, run: this.d.sdlc?.gh ?? sdlcGh, readableMetadata: this.publicMetadataText,
         recordMerge: record=>this.recordMergeResult(task.id,by,record,artifactCurrent),
-        beforeMerge: () => {
+        beforeMerge: queue => {
           if (!this.mergeAuthority(by)) return "merge authority changed during the merge check: nothing was run";
-          // The queue used every link, not only the subject. A changed dependency artifact or ordering edge invalidates that remote evidence.
+          // Only the links this queue read count: a change to one of those (a dependency artifact, an ordering edge, a relink, a new holder of an open PR) invalidates
+          // that remote evidence, and any other task's change does not. Both sides are projected through the same queue, so a new holder of an open PR shows.
           const currentConfig = this.d.sdlc?.config() ?? sdlcConfig(undefined);
-          return workflowHash({ config: currentConfig, links: this.deliveryLinks(currentConfig) }) === queueIdentity
+          const currentLinks = this.deliveryLinks(currentConfig), currentSubject = currentLinks.find(link => link.id === task.id);
+          return currentSubject && workflowHash({ config: currentConfig, links: this.queueLinks(currentLinks, currentSubject, queue) }) === workflowHash({ config, links: this.queueLinks(links, subject, queue) })
             ? undefined : "merge queue inputs changed during the merge check: nothing was run";
         },
         // Read synchronously at dispatch, after the last PR read: the task (state, receipt, privacy, dependencies, findings), the configuration and mode in force, and whether
@@ -3336,7 +4117,7 @@ export class Tasks {
         fresh: () => {
           const now = this.d.board.get(task.id), cfg = this.d.sdlc?.config() ?? sdlcConfig(undefined);
           const current = now && this.deliveryLinks(cfg).find(link => link.id === now.id);
-          return now && current ? { subject: current, state: now.state, config: cfg, mode: opts.dryRun ? "dry-run" : mergeModeFor(cfg, now.sdlc?.repo), allowed: this.mergeAuthority(by) && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError } : undefined;
+          return now && current ? { subject: current, state: now.state, config: cfg, mode: opts.dryRun ? "dry-run" : mergeModeFor(cfg, now.sdlc?.repo), allowed: this.mergeAuthority(by) && !this.d.sweepHeld?.() && !this.d.bus.isRecoveryHeld && !this.d.bus.storageError } : undefined;
         } });
       if(mode==="on" && !outcome.ran && "refused" in outcome.decision)this.recordMergeRefusal(task.id,by,outcome.decision.refused);
       if(outcome.result?.state==="merged") {
@@ -3436,6 +4217,12 @@ export class Tasks {
       if (d.path && (!this.nameable(d.path) || matchesPolicy(this.d.cwd, d.path, this.d.piiPaths ?? [], true))) { const { path: _privatePath, ...metadata } = d; return metadata; }
       return d;
     });
+    // #481 AC12: release interval, lead time from approval to release and hotfix rate, from the shipped releases' recorded history; unknown stays null (never 0).
+    // Releases whose scope holds private work are left out, like the per-release report does.
+    const rowsNow = this.d.board.list();
+    const publicShipped = this.d.board.releases().filter(release => !rowsNow.some(task => task.release === release.id && this.isPii(task)));
+    const metrics = publicShipped.some(release => release.state === "shipped") ? releaseMetrics(publicShipped, rowsNow.filter(task => !this.isPii(task))) : undefined;
+    if (metrics) report.releaseMetrics = metrics;
     const trains = this.d.board.releases().filter(release => release.train && ["active", "frozen"].includes(release.state));
     if (trains.length) {
       const planned = trains.map(release => {
@@ -3564,11 +4351,12 @@ export class Tasks {
     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 evalResult = task.sdlc && !this.isPii(task) ? await readEvalFor(config, evidence, task.sdlc.repo, read) : 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, integrity);
+      config.mode !== "off" ? this.planReport(this.d.board.get(current.id)!, evidence) : undefined, integrity, evalResult);
   }
 
   /** #481 S1: only build work starts from an accepted spec. */
@@ -3595,6 +4383,7 @@ export class Tasks {
 
   /** Build entry with a live readback of the spec's body edit time (#481 S1): enforce refuses, advise notifies, off does nothing. */
   async specGate(by: PeerId, id: unknown): Promise<void> {
+    requireLocalTaskPeer(by);
     const task = this.need(id, false, true);
     if (!this.specGated(task) || task.owner !== by && by !== USER) return; // accept reports its own refusals
     const accepted = task.sdlc?.acceptance;
@@ -3605,6 +4394,7 @@ export class Tasks {
 
   /** #481 S1: a build stage change by an agent re-reads the body edit time first, as accept does. */
   async specStageGate(by: PeerId, id: unknown, input: unknown): Promise<void> {
+    requireLocalTaskPeer(by);
     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>;
@@ -3640,6 +4430,8 @@ export class Tasks {
     return { applicability: "unknown", redFirst: "unknown", fileState: "unknown", modifiedTests: [], blockers: [privateTask ? "test integrity: private evidence unavailable" : "test integrity: current evidence unknown"] };
   }
 
+  /** The eval record the last approval-time lifecycle read produced for a task; consumed by the verdict that follows it. */
+  private readonly evalRecords = new Map<number, string>();
   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;
@@ -3653,16 +4445,24 @@ export class Tasks {
     };
     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 evalResult = receipt && !this.isPii(task) ? await readEvalFor(config, evidence, receipt.repo, read) : undefined;
     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, 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;
+    const status = sdlcStatus(config, receipt, evidence, this.workflowView(current), undefined, this.isPii(current) ? [] : findings ?? this.reviewFindingSets(current), current.refs.commit, planReport, integrity, evalResult);
+    // #481 S5: review entry keeps the eval gate's own blockers (its check, and in enforce its evidence gaps), like the premature-review rule does for the ordinary required checks.
+    const evalNames = evalRequiredChecks(config, evidence).filter(name => !config.requiredChecks.includes(name));
+    const evalBlocker = (blocker: string) => evalNames.some(name => blocker.startsWith(`required check ${name}:`)) || evalGapBlockers(status.evalGate).includes(blocker);
+    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:") || evalBlocker(blocker)), ...(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), ...testIntegrityBlockers(integrity)])];
+    // #481 S5: the recorded pass rate and suite version ride the approval note; a code-only PR, an unconfigured gate or an unreported value records nothing.
+    const gate = status.evalGate;
+    if (transition === "approval" && gate?.state === "passed" && gate.passRate !== undefined && gate.suite !== undefined && !this.isPii(task)) this.evalRecords.set(task.id, `Eval gate: ${gate.check} passed at ${evidence!.head.slice(0, 12)}, pass rate ${gate.passRate}, suite ${gate.suite}`);
+    else this.evalRecords.delete(task.id);
+    const advice = [...new Set([...blockers, ...planConformanceBlockers(planReport), ...testIntegrityBlockers(integrity), ...evalAdvice(status.evalGate)])];
     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;
   }
@@ -3746,6 +4546,7 @@ export class Tasks {
    * announced like one found at assignment (issue #31).
    */
   accept(by: PeerId, id: unknown, plan?: unknown, refs?: unknown): Task {
+    requireLocalTaskPeer(by);
     const metadata = acceptRefs(refs);
     const task = this.need(id, false, true);
     this.mine(task, by, "owner", true);
@@ -3891,9 +4692,10 @@ export class Tasks {
    * Without `check` this reads the board only: no file is opened, so no row claims `changedSinceReview`. With `check` every file is measured now (one task at a time).
    * Every path goes through `publicDeliverables`, so a PII task or a path under `pii.paths` shows id, hash and size only.
    */
-  async deliverableList(opts: { task?: number; approvedOnly?: boolean; check?: boolean } = {}): Promise<DeliverableRow[]> {
+  async deliverableList(opts: { task?: number; approvedOnly?: boolean; check?: boolean; visible?: (task: Task) => boolean } = {}): Promise<DeliverableRow[]> {
     const rows: DeliverableRow[] = [];
-    const tasks = (opts.task !== undefined ? [this.d.board.get(opts.task)].filter((task): task is Task => !!task) : this.d.board.list()).sort((a, b) => b.id - a.id);
+    // #933: `visible` drops a task before anything is read or measured (an agent's list holds only what hub_task_show shows it).
+    const tasks = (opts.task !== undefined ? [this.d.board.get(opts.task)].filter((task): task is Task => !!task) : this.d.board.list()).filter(task => !opts.visible || opts.visible(task)).sort((a, b) => b.id - a.id);
     for (const task of tasks) {
       const delivered = latestDeliverables(task.history);
       if (!delivered) continue;
@@ -4081,6 +4883,7 @@ export class Tasks {
    * duplicate notice is the price of never losing one.
    */
   replayHeld(peer: PeerId): void {
+    requireLocalTaskPeer(peer);
     const finished = this.d.board.list().filter((u) => (u.state === "approved" || u.state === "in_review") && u.owner && !this.isPii(u));
     for (const t of this.d.board.list()) {
       if (!OPEN.includes(t.state) || t.owner !== peer || this.isPii(t)) continue;
@@ -4138,6 +4941,19 @@ export class Tasks {
     return [head, "The done counts once the files did not change between two calls and the others have stopped.", ...lines, facts?.text ?? ""].filter(Boolean).join("\n");
   }
 
+  /**
+   * #901: which check key produced this result, and how many citation keys the example citation check said were unresolved. The key is the hub's own selection (`Deps.checkKey`, the lookup
+   * `Deps.check` makes), never read from output; without that dependency it is not recorded. The count is read only from the example check's own last line (`citations: N declared keys, M missing`, scripts/check-citations.ts);
+   * a tail without that exact line, or with a number past the bound, records no count: unknown, never zero.
+   */
+  private checkProvenance(task: Task, tail: string): Pick<HistoryEntry, "checkKey" | "missingKeys"> {
+    let key: string | undefined;
+    try { key = this.d.checkKey?.(task.class, task); } catch { key = undefined; }
+    const lines = tail.split("\n").map(line => line.trim()).filter(Boolean);
+    const match = /^citations: (\d{1,6}) declared keys, (\d{1,6}) missing$/.exec(lines.at(-1) ?? "");
+    return { ...(key ? { checkKey: key } : {}), ...(match ? { missingKeys: Number(match[2]) } : {}) };
+  }
+
   private async finishChecked(id: number, by: PeerId, summary: string | undefined, command: string, seen: { events: number; owner: PeerId | null }, withheld: boolean): Promise<void> {
     const result = await this.d.runCheck!(command).catch((e: Error) => ({ code: null, timedOut: false, interrupted: false, tail: e.message }));
     this.checking.delete(id);
@@ -4161,12 +4977,12 @@ export class Tasks {
         this.tell(task, `Task #${id}: its check passed, but the overlapping work or the files changed while it ran (turn-free integration). Call hub_task_done again.`, pii);
         return;
       }
-      this.d.board.update(id, HUB, "check passed", {}, `${outcome}\n${result.tail}`.trim());
+      this.d.board.update(id, HUB, "check passed", {}, `${outcome}\n${result.tail}`.trim(), this.checkProvenance(task, result.tail));
       // The output goes to the reviewer with the done note, not into shared memory: nobody screened it.
       await this.complete(this.d.board.get(id)!, by, `${summary ?? ""}\nCheck: ${outcome}`.trim(), undefined, result.tail, withheld);
       return;
     }
-    this.d.board.update(id, HUB, "check failed", {}, `${outcome}\n${result.tail}`.trim());
+    this.d.board.update(id, HUB, "check failed", {}, `${outcome}\n${result.tail}`.trim(), this.checkProvenance(task, result.tail));
     this.cohorts.withdraw(id); // open again: its done intent no longer counts (issue #107)
     if (task.owner) this.d.board.recordOutcome(task.owner, task.class, false);
     this.contradict(task);
@@ -4203,7 +5019,8 @@ export class Tasks {
     this.warmRepository({ ...task, refs: { ...task.refs, ...completedRefs } });
     const noWrites = this.noWritesRecorded({ ...task, refs: { ...task.refs, ...completedRefs } });
     const capacity = this.capacityBefore(task);
-    const next = this.d.board.update(task.id, by, "done", { codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...completedRefs } }), state: reviewer ? "in_review" : "approved", ...(selection ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    const next = this.d.board.update(task.id, by, "done", { codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...completedRefs } }), state: reviewer ? "in_review" : "approved", ...(selection ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection, { ...task, refs: { ...task.refs, ...completedRefs } }), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    this.queueReviewWritten(next);
     this.writePlannerNotices(next, capacity, next.state === "approved");
     this.ciWatchers.cancel(next.id); this.heldReviews.delete(next.id); // a newer head or a move ends the old head's watcher (#785 P1b)
     this.cohorts.closed(next.id); // its owner's next native turn end settles it in its cohort (issue #107)
@@ -4323,7 +5140,7 @@ export class Tasks {
     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);
+        const holders = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && 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");
       }
       // #694: the board copy seen through the same staged identity link the caller's task carries.
@@ -4532,6 +5349,7 @@ export class Tasks {
 
   /** Host-only admission for a queued review after asynchronous native preparation. */
   reviewBindingCurrent(by: PeerId, id: number, binding: { head?: string; flowRevision?: number }): boolean {
+    requireLocalTaskPeer(by);
     const task = this.d.board.get(id);
     return !!task && task.state === "in_review" && task.reviewer === by && !this.isPii(task)
       && this.reviewRequestRevision(task) === binding.flowRevision && this.reviewHead(task) === binding.head;
@@ -4539,6 +5357,7 @@ export class Tasks {
 
   /** Host-only failure report, bound to the exact review request and its still-current child generation. */
   async retryReviewer(id: number, failedPeer: PeerId, failure: { head?: string; flowRevision?: number; cause: "start_failed" | "quota" | "no_verdict" }, current: () => boolean, onReoffered?: () => void): Promise<Task> {
+    requireLocalTaskPeer(failedPeer);
     if (!failure || !["start_failed", "quota", "no_verdict"].includes(failure.cause) || !/^[a-z][a-z0-9-]{0,63}$/.test(failedPeer) || !Number.isSafeInteger(failure.flowRevision) || failure.flowRevision! < 1 || failure.head !== undefined && (typeof failure.head !== "string" || text(failure.head) !== failure.head || Buffer.byteLength(failure.head) > 1200 || /\p{Cc}/u.test(failure.head))) throw new PreEffectToolRefusal("invalid reviewer failure binding");
     const valid = () => {
       const task = this.need(id, false, true);
@@ -4557,7 +5376,8 @@ export class Tasks {
     valid();
     const note = manual ? "named reviewer recorded no verdict; the person must review"
       : selection?.reviewSelection ? this.assignmentNote(`reviewer unavailable: ${failure.cause}`, selection) : "no declared reviewer pool can receive the fallback; the person must review";
-    const next = this.d.board.update(task.id, HUB, "reviewer unavailable", { reviewer }, note, { ...this.reviewMetadata(selection), ...(reviewer === USER ? { reviewBlocked: true } : {}), reviewerFailure: { peer: failedPeer, cause: failure.cause, ...(failure.head ? { head: failure.head } : {}) } }, task.history.length);
+    const next = this.d.board.update(task.id, HUB, "reviewer unavailable", { reviewer }, note, { ...this.reviewMetadata(selection, task), ...(reviewer === USER ? { reviewBlocked: true } : {}), reviewerFailure: { peer: failedPeer, cause: failure.cause, ...(failure.head ? { head: failure.head } : {}) } }, task.history.length);
+    this.queueReviewWritten(next);
     this.releaseNotice(`task ${this.publicTitle(next)}: former review request withdrawal incomplete`, () => this.withdrawRoleRequest(task, next, "reviewer"));
     let offered = false;
     if (reviewer === USER) {
@@ -4637,6 +5457,7 @@ export class Tasks {
   }
 
   async review(by: PeerId, id: unknown, verdict: unknown, note?: string, unmet?: unknown, head?: unknown, coverage?: unknown, findings?: unknown): Promise<Task> {
+    const requestCheck = this.requestCheck(by);
     const authority = by === USER ? undefined : this.d.reviewAuthority?.(by, Number(id));
     let findingGuard: ((task: Task) => void) | undefined;
     // #520: what the coverage was checked against, pinned through every await: the commit and the lifecycle receipt (the
@@ -4644,6 +5465,7 @@ export class Tasks {
     let covered: { commit: string | undefined; receipt: string } | undefined;
     let conformanceIdentity: string | undefined;
     const valid = (): Task => {
+      requestCheck();
       const refused = authority?.();
       if (refused) throw new PreEffectToolRefusal(refused); // rechecked after every await, right before each write
       const t = this.need(id, false, true);
@@ -4749,7 +5571,12 @@ export class Tasks {
         }
       }
     }
-    if (verdict === "approved" && this.d.sdlc && this.d.sdlc.config().mode !== "off") { await this.lifecycleGate(task, "approval", reviewedHead, proposedSets(task)); task = valid(); }
+    if (verdict === "approved" && this.d.sdlc && this.d.sdlc.config().mode !== "off") {
+      this.evalRecords.delete(task.id);
+      await this.lifecycleGate(task, "approval", reviewedHead, proposedSets(task)); task = valid();
+      const record = this.evalRecords.get(task.id); this.evalRecords.delete(task.id);
+      if (record) note = `${note ?? ""}\n${record}`.trim();
+    }
     let candidate: Extract<CandidateInput, { kind: "fail" }> | undefined;
     if (verdict === "changes_requested" && !evidenceOnly && items.length && this.d.candidates && !withheld && !this.isPii(task) && !this.d.privateTurn?.(by)) {
       const input: CandidateInput = { project: this.d.store?.project ?? this.d.project, kind: "fail", approach: this.publicTitle(task), symptom: items.join("\n"),
@@ -4792,12 +5619,14 @@ export class Tasks {
       this.autoMerge(next, this.mirrorVerdict(next, by, "approved", reviewedHead ?? next.sdlc?.reviewedHead, note, withheld));
       // A proposal storage failure cannot roll back the saved verdict; another matching verdict retries it.
       this.releaseNotice(`task #${next.id}: review saved but recurring-finding proposal unavailable`, () => this.proposeRecurringFindings(next, by, parsed, withheld));
+      this.releaseNotice(`task #${next.id}: review saved but recurring-criterion proposal unavailable`, () => this.proposeCriterionCandidates(next, by, withheld));
       return next;
     }
     this.ciWatchers.cancel(task.id); this.heldReviews.delete(task.id);
     const rejected = this.d.board.update(task.id, by, "changes_requested", { state: "changes_requested", rejections: evidenceOnly ? task.rejections : task.rejections + 1 }, note, flag);
     void this.mirrorVerdict(rejected, by, "changes_requested", reviewedHead ?? rejected.sdlc?.reviewedHead, note, withheld);
     if (!evidenceOnly) this.releaseNotice(`task #${rejected.id}: review saved but recurring-finding proposal unavailable`, () => this.proposeRecurringFindings(rejected, by, parsed, withheld));
+    if (!evidenceOnly) this.releaseNotice(`task #${rejected.id}: review saved but recurring-criterion proposal unavailable`, () => this.proposeCriterionCandidates(rejected, by, withheld));
     if (candidate && !pii && !this.d.privateTurn?.(by) && this.candidateTextAllowed(JSON.stringify({ candidate, refs: rejected.refs, plan: rejected.plan }), rejected)) {
       try { this.d.memoryCheck?.(); this.d.candidates?.put({ ...candidate, evidenceRefs: [...candidate.evidenceRefs, `review:${rejected.id}:${rejected.history.length}`] }, "public"); } catch { /* a saved review remains authoritative if the optional sidecar fails */ }
     }
@@ -4837,7 +5666,7 @@ export class Tasks {
    * the review or the task reaches it; a PII task's notice is private. With no conductor the person sees one console notice instead.
    */
   private tellConductorEvidenceOnly(task: Task, reviewer: PeerId): void {
-    const conductors = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor).filter(actor => actor !== reviewer);
+    const conductors = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor).filter(actor => actor !== reviewer);
     const text = evidenceOnlyNotice(task.id, reviewer);
     if (!conductors.length) { this.releaseNotice(text); return; }
     this.releaseNotice(`task #${task.id}: could not tell the conductor a code-scope review was evidence-only`, () => {
@@ -4847,6 +5676,7 @@ export class Tasks {
 
   /** Task-level escalation: the next attached peer in the class's escalate_to takes over, with the history. */
   async escalate(by: PeerId, id: unknown, why = "by hand", reason: TaskMoveReason | undefined = by === HUB ? undefined : "manual", preEffect = false): Promise<Task> {
+    requireLocalTaskPeer(by);
     let task = this.need(id, true, preEffect);
     const list = this.d.routing().classes[task.class]?.escalate_to ?? [];
     if (task.state === "changes_requested") task = this.d.board.update(task.id, HUB, "reopened", { state: "in_progress" });
@@ -4908,8 +5738,33 @@ export class Tasks {
     });
   }
 
+  /** Preserve explicit intent across a policy reload; recheck conductor authority after every await. */
+  private explicitQueueAssignment(by: PeerId, role: Exclude<TaskAssignmentRole, "planner">, preEffect: boolean): { role: "owner" | "reviewer"; current: () => void } | undefined {
+    if (by === USER) return { role, current: () => {} };
+    const current = () => {
+      const holders = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([peer]) => peer);
+      return holders.length === 1 && holders[0] === by && this.d.bus.isRostered(by);
+    };
+    if (!current()) return undefined;
+    return { role, current: () => { if (!current()) throw new (preEffect ? PreEffectToolRefusal : Error)("only the current configured conductor may override assignment admission"); } };
+  }
+
+  private configuredManualConductor(by: PeerId): boolean {
+    if (by === USER || by === HUB || isRemotePeerId(by)) return false;
+    const holders = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("conductor")).map(([peer]) => peer);
+    return holders.length === 1 && holders[0] === by;
+  }
+  private conductorManualCheck(by: PeerId, preEffect: boolean): () => void {
+    return () => {
+      if (!this.configuredManualConductor(by) || !this.d.bus.isRostered(by)) throw new (preEffect ? PreEffectToolRefusal : Error)("only the console user or the current configured conductor may unassign a task role");
+    };
+  }
+
   /** Caller authority is checked by the daemon; keep the real actor in task history. */
   async assignTo(id: unknown, peer: PeerId, by: PeerId = USER, preEffect = false, role: TaskAssignmentRole = "owner", expectedFlowRevision?: number): Promise<Task> {
+    requireLocalTaskPeer(by); requireLocalTaskPeer(peer);
+    const conductorManual = this.configuredManualConductor(by), manualCurrent = conductorManual ? this.conductorManualCheck(by, preEffect) : undefined;
+    manualCurrent?.();
     if (role !== "owner" && role !== "reviewer" && role !== "planner") throw new (preEffect ? PreEffectToolRefusal : Error)("role must be owner, reviewer or planner");
     if (role === "planner") {
       if (by !== USER) throw new PreEffectToolRefusal("only the person may name a task planner");
@@ -4923,9 +5778,11 @@ export class Tasks {
       return next;
     }
     if (role === "reviewer" && by !== USER) {
-      const conductors = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
+      const conductors = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
       if (conductors.length !== 1 || conductors[0] !== by) throw new (preEffect ? PreEffectToolRefusal : Error)("only the console user or the configured conductor may name a reviewer");
     }
+    const queueAssignment = this.explicitQueueAssignment(by, role, preEffect);
+    queueAssignment?.current();
     const task = this.need(id, role === "owner", preEffect);
     this.checkFlowRevision(task, expectedFlowRevision, preEffect);
     if (!this.d.bus.isRostered(peer)) throw new (preEffect ? PreEffectToolRefusal : Error)(`${peer} is off roster; add it to the roster before assigning work`);
@@ -4933,20 +5790,23 @@ export class Tasks {
     if (role === "reviewer") {
       if (!OPEN.includes(task.state) && task.state !== "in_review") throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id} is ${task.state}: its reviewer can no longer change`);
       this.ready(task, preEffect);
-      const a = assign(task, this.states(), this.d.routing(), { candidates: [], namedReviewer: peer, ...(task.owner ? { notReviewer: task.owner } : {}), ...this.weights(task.class, task) });
+      const a = assign(task, this.states(), this.d.routing(), { candidates: [], namedReviewer: peer, ...(task.owner ? { notReviewer: task.owner } : {}), ...this.weights(task.class, task), ...(queueAssignment ? { queueOverride: queueAssignment.role } : {}) });
       if (a.reviewer !== peer) throw new (preEffect ? PreEffectToolRefusal : Error)(`cannot name ${peer} as reviewer: ${a.trace.filter(line => line.includes("reviewer") || line.includes("pii")).join("; ")}`);
       const admission = task.state === "in_review" ? await this.reviewRequestAdmission(task, undefined, preEffect, by) : undefined;
       // Every runtime authority check precedes the final write, including revocations during the metadata await.
+      manualCurrent?.();
+      queueAssignment?.current();
       const current = this.need(task.id, false, preEffect);
       if (current.history.length !== task.history.length) throw new (preEffect ? PreEffectToolRefusal : Error)("task changed during reviewer admission");
       if (by !== USER) {
-        const holders = Object.entries(this.d.roles ?? {}).filter(([, roles]) => Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
+        const holders = Object.entries(this.d.roles ?? {}).filter(([peer, roles]) => !isRemotePeerId(peer) && Array.isArray(roles) && roles.includes("conductor")).map(([actor]) => actor);
         if (holders.length !== 1 || holders[0] !== by) throw new (preEffect ? PreEffectToolRefusal : Error)("only the console user or the configured conductor may name a reviewer");
       }
       if (!this.d.bus.isRostered(peer)) throw new (preEffect ? PreEffectToolRefusal : Error)(`${peer} is off roster`);
       this.requireCapabilities(current, peer, role, preEffect);
-      const eligible = assign(current, this.states(), this.d.routing(), { candidates: [], namedReviewer: peer, ...(current.owner ? { notReviewer: current.owner } : {}), ...this.weights(current.class, current) });
+      const eligible = assign(current, this.states(), this.d.routing(), { candidates: [], namedReviewer: peer, ...(current.owner ? { notReviewer: current.owner } : {}), ...this.weights(current.class, current), ...(queueAssignment ? { queueOverride: queueAssignment.role } : {}) });
       if (eligible.reviewer !== peer) throw new (preEffect ? PreEffectToolRefusal : Error)("reviewer is no longer eligible");
+      queueAssignment?.current();
       const next = this.d.board.update(task.id, by, "reviewer changed", { reviewer: peer }, this.assignmentNote(`named reviewer ${peer}`, a), { reason: "manual" }, expectedFlowRevision);
       if (next.state === "in_review" && task.reviewer && task.reviewer !== peer) {
         this.withdrawRoleRequest(task, next, "reviewer");
@@ -4955,15 +5815,23 @@ export class Tasks {
       return next;
     }
     // Work that waits is handed to nobody yet (issue #207): the peer becomes its reserved owner instead.
-    if (!this.waitsFor(task).length) return this.assignOwner(task, by, { candidates: [peer], namedOwner: peer, event: "reassigned", reason: "manual", override: by === USER, expectedFlowRevision, refuseNamed: preEffect ? "pre" : "plain" });
-    const next = this.d.board.update(task.id, by, "reserved", { reserved: peer }, `for ${peer}`, { reason: "manual" }, expectedFlowRevision);
+    if (!this.waitsFor(task).length) return this.assignOwner(task, by, { candidates: [peer], namedOwner: peer, event: "reassigned", reason: "manual", override: by === USER, expectedFlowRevision, refuseNamed: preEffect ? "pre" : "plain", ...(conductorManual ? { conductorManual: true as const } : {}), ...(queueAssignment ? { queueOverride: "owner" as const } : {}), current: () => { manualCurrent?.(); queueAssignment?.current(); } });
+    manualCurrent?.();
+    queueAssignment?.current();
+    const next = this.d.board.update(task.id, by, "reserved", { reserved: peer }, `for ${peer}`, { reason: "manual", ...(conductorManual ? { conductorManual: true as const } : {}) }, expectedFlowRevision);
     this.releaseNotice(`task ${this.publicTitle(next)} reserved for ${peer} by ${by}; it is offered to ${peer} first once what it waits for is approved`);
     return next;
   }
 
-  /** Person-only removal without routing a replacement. The history marker suppresses later automatic owner offers. */
+  /** Explicit removal without routing a replacement; host history preserves manual intent across role changes. */
   async unassign(id: unknown, by: PeerId = USER, preEffect = false, role: TaskAssignmentRole = "owner", expectedFlowRevision?: number): Promise<Task> {
-    if (by !== USER) throw new (preEffect ? PreEffectToolRefusal : Error)("only the console user may unassign a task role");
+    const authority = by === USER ? undefined : this.conductorManualCheck(by, preEffect);
+    const current = authority && (() => {
+      authority();
+      if (this.d.privateTurn?.(by)) throw new (preEffect ? PreEffectToolRefusal : Error)("conductor task mutations are unavailable during a private turn");
+      if (this.d.cancellationHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) throw new (preEffect ? PreEffectToolRefusal : Error)("recovery or shutdown is holding task writes");
+    });
+    current?.();
     if (role !== "owner" && role !== "reviewer") throw new (preEffect ? PreEffectToolRefusal : Error)("role must be owner or reviewer");
     const task = this.need(id, false, preEffect);
     this.checkFlowRevision(task, expectedFlowRevision, preEffect);
@@ -4971,7 +5839,8 @@ export class Tasks {
     if (role === "owner") {
       if (!OPEN.includes(task.state)) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id} is ${task.state}: its owner cannot be unassigned`);
       if (!task.owner && !task.reserved) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: no owner or owner reservation to unassign`);
-      const next = this.d.board.update(task.id, by, "unassigned", { owner: null, reserved: null, ...(task.state === "proposed" ? {} : { state: "proposed" as const }) }, `person unassigned ${[task.owner, task.reserved].filter(Boolean).join(" and ")}`, { reason: "manual" }, expectedFlowRevision);
+      current?.();
+      const next = this.d.board.update(task.id, by, "unassigned", { owner: null, reserved: null, ...(task.state === "proposed" ? {} : { state: "proposed" as const }) }, `${by === USER ? "person" : "conductor"} unassigned ${[task.owner, task.reserved].filter(Boolean).join(" and ")}`, { reason: "manual", ...(current ? { conductorManual: true as const } : {}) }, expectedFlowRevision);
       this.cohorts.leave(task.id);
       this.withdrawRoleRequest(task, next, "owner");
       return next;
@@ -4979,7 +5848,8 @@ export class Tasks {
     if (!OPEN.includes(task.state) && task.state !== "in_review") throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id} is ${task.state}: its reviewer cannot be unassigned`);
     if (!task.reviewer) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: no reviewer to unassign`);
     if (task.reviewer === USER && this.isPii(task)) throw new (preEffect ? PreEffectToolRefusal : Error)(`task #${task.id}: the human reviewer is required for PII work`);
-    const next = this.d.board.update(task.id, by, "reviewer changed", { reviewer: null }, `person unassigned reviewer ${task.reviewer}`, { reason: "manual" }, expectedFlowRevision);
+    current?.();
+    const next = this.d.board.update(task.id, by, "reviewer changed", { reviewer: null }, `${by === USER ? "person" : "conductor"} unassigned reviewer ${task.reviewer}`, { reason: "manual", ...(current ? { conductorManual: true as const } : {}) }, expectedFlowRevision);
     this.withdrawRoleRequest(task, next, "reviewer");
     return next;
   }
@@ -4989,11 +5859,13 @@ export class Tasks {
    * the usual constraints. Tasks it was reviewing get another reviewer. Moves are reported, never taken back automatically.
    */
   async reassignForPause(peer: PeerId, context: string | undefined, urgentOnly = false): Promise<{ id: number; title: string; to: PeerId | null; role: "owner" | "reviewer" }[]> {
+    requireLocalTaskPeer(peer);
     return this.reassignWork(peer, context, urgentOnly, false);
   }
 
   /** Read-only preview using the same assignment constraints as the roster relay. */
   rosterPreview(peer: PeerId): { id: number; title: string; role: "owner" | "reviewer"; to: PeerId | null }[] {
+    requireLocalTaskPeer(peer);
     const routing = this.d.routing();
     return this.d.board.list().filter(task => !isClosedTaskState(task.state) && (task.owner === peer || task.reviewer === peer)).map(task => {
       const owner = task.owner === peer;
@@ -5007,6 +5879,7 @@ export class Tasks {
 
   /** A roster removal offers work through the quota relay's constraints, preserving assignments nobody can take. */
   async reassignForRoster(peer: PeerId, current?: () => void): Promise<{ id: number; title: string; to: PeerId | null; role: "owner" | "reviewer" }[]> {
+    requireLocalTaskPeer(peer);
     return this.reassignWork(peer, undefined, false, true, current);
   }
 
@@ -5055,7 +5928,8 @@ export class Tasks {
           continue;
         }
         current?.();
-        const next = this.d.board.update(task.id, HUB, "reviewer changed", { reviewer }, this.assignmentNote(why, a), this.reviewMetadata(a));
+        const next = this.d.board.update(task.id, HUB, "reviewer changed", { reviewer }, this.assignmentNote(why, a), this.reviewMetadata(a, task));
+        this.queueReviewWritten(next);
         moved.push({ id: task.id, title: this.publicTitle(task), to: reviewer, role: "reviewer" });
         current?.();
         if (next.state === "in_review" && reviewer && reviewer !== USER) {
@@ -5090,11 +5964,13 @@ export class Tasks {
 
   /** Candidate only: the person remains the sole acceptance authority. */
   async correct(by: PeerId, input: unknown): Promise<string> {
+    const requestCheck = this.requestCheck(by);
     const args = correctionInput(input);
     const st = this.d.store;
     if (!st || !this.d.candidates) throw new PreEffectToolRefusal("memory correction unavailable");
     const screen: MemoryScreen = rows => this.d.candidateScreen?.(rows) ?? withoutPii(rows, this.d.routing(), this.d.cwd, this.d.piiPaths ?? []);
     const valid = () => {
+      requestCheck();
       this.d.memoryCheck?.();
       if (this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("memory correction unavailable during a private turn");
       if (!this.candidateTextAllowed(JSON.stringify(args))) throw new PreEffectToolRefusal("memory correction withheld by privacy policy");
@@ -5169,6 +6045,7 @@ export class Tasks {
   }
   /** A person links a board task of this project to a long-term task (`ahub goal link`). */
   linkGoal(by: PeerId, id: unknown, ref: unknown): string {
+    requireLocalTaskPeer(by);
     const task = this.d.board.get(Number(id));
     if (!task) throw new Error(`no task #${String(id).slice(0, 12)}`);
     const goal = this.goalFor(by, ref);