@staix/agent-hub 0.27.0 → 0.29.0

package/src/hub/tasks.ts

@@ -20,7 +20,7 @@ import { publicTestIntegrity, readTestIntegrity, testIntegrityBlockers, type Tes
 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 { cleanCostPlan, costMetrics, CostScopeError, type CostPlan, type ReviewCost } from "./cost-governance.ts";
 import { qualifiedTitleRepos, siblingTitleRefs, specRefs } from "./spec-read.ts";
 import { folderDetail, MAX_NEW_PER_POLL, scheduleNext, 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";
@@ -64,23 +64,26 @@ import { isAbsolute, relative, resolve } 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 { 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 { 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, type SpecAck, type SpecTaskReport } 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, isRemotePeerId, 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, writesRepository, 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";
 import { TaskRepositories } from "./task-repository.ts";
 import { mainCheckoutWarning } from "./main-checkout.ts";
 import { PreEffectToolRefusal } from "./tool-refusal.ts";
-import { coverageGap, renderReviewBrief, type ReviewBrief } from "./review-brief.ts";
+import type { TaskWorktreePort } from "./task-worktree.ts";
+import { coverageGap, renderReviewBrief, renderSpecTaskReport, type BriefFile, type ReviewBrief } from "./review-brief.ts";
+import { DEFAULT_SPECS_CONFIG, type SpecsConfig } from "./specs-config.ts";
+import type { SpecsCheckReport, SpecsCoverReport } from "./specs.ts";
 import { definitionOf as builtinDefinitionOf } from "../adapters/registry.ts";
 import { ADAPTERS, DEFAULT_REVIEW_POOL, definitionOf, familyOf, type ProjectAdapterCatalog } from "../adapters/registry.ts";
-import { plannerGrooming, nextSweep, taskSweepConfig, type TaskSweepConfig, type SweepRecord } from "./task-sweep.ts";
+import { plannerGrooming, nextSweep, plannedStartPending, taskSweepConfig, type TaskSweepConfig, type SweepRecord } from "./task-sweep.ts";
 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";
+import { planningIssueReceipt, linkedReceipt, openPrFor, readPrCostHistory, readReviewReadiness, reviewReadinessFromEvidence, type PrEvidence, type ReviewReadiness, readPlanIssueMetadata, canonicalStage, checklistOf, readSdlcPr, readSdlcPrHead, 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");
@@ -88,6 +91,15 @@ function requireLocalTaskPeer(peer: unknown): void {
 
 export type TaskAssignmentRole = "owner" | "reviewer" | "planner";
 
+interface PreparedSpecInspection {
+  report?: SpecTaskReport;
+  policyKey: string;
+  repo?: string;
+  head: string;
+  privateTurn: boolean;
+  pii: boolean;
+}
+
 export interface ReleaseWindow { at: number; host: boolean; quota: boolean; idle: boolean; reasons: string[]; current?: () => boolean; close?: () => Promise<void>; }
 
 export interface TasksDeps {
@@ -134,6 +146,14 @@ export interface TasksDeps {
   /** #520: the review brief for a task's commit (git only, bounded); undefined when the task names no commit. */
   prepareReviewBrief?: (task: Task) => Promise<void>;
   reviewBrief?: (task: Task) => ReviewBrief | { unavailable: string } | undefined;
+  /** Current public coverage for a task's declared paths; absent when notices are disabled or no specs exist. */
+  specNotice?: (task: Task) => SpecsCoverReport | undefined;
+  /** Inspect spec metadata at a verified task head; undefined is authoritative quiet (no specs/stamps or review off). */
+  inspectSpecs?: (task: Task, head: string, changedFiles: readonly BriefFile[] | undefined, acks: readonly SpecAck[]) => Promise<SpecTaskReport | undefined>;
+  /** Effective shared and machine-local specs policy. */
+  specsConfig?: () => SpecsConfig;
+  /** Explicit, read-only inspection remains available when task notices are disabled. */
+  specsRead?: (action: "check" | "covers", paths: readonly string[]) => SpecsCheckReport | SpecsCoverReport;
   /** Host-verified existing symbols at this task's admitted completion head; never plan guesses. */
   memorySymbolNodes?: (task: Task) => MemorySymbolNodes | undefined;
   sdlc?: { config: () => SdlcConfig; gh?: SdlcGh };
@@ -198,6 +218,8 @@ export interface TasksDeps {
   review?: { adaptive: boolean; min_reviews: number; pool?: readonly string[]; rerotate?: boolean; same_family?: "fallback" | "never" };
   /** Peers whose recent deliveries all failed, with the reason (issue #89); routing skips them. */
   capabilities?: () => Record<PeerId, PeerCapabilities>;
+  /** #1115: the hub makes, commits and clears the task worktree of a hub-sandboxed peer. Absent: such a peer keeps the #1081 refusal. */
+  taskWorktree?: TaskWorktreePort;
   repository?: string;
   offerRead?: (peer: PeerId, envelopeId: string) => boolean;
   offerPullOnly?: (peer: PeerId) => boolean;
@@ -375,7 +397,7 @@ function cleanPlan(input: unknown, profile: ProfileSelection = "dev"): TaskPlan
     if (items.length) evidence[key] = items;
   }
   let scope: CostPlan;
-  try { scope = cleanCostPlan(r); } catch { throw new PreEffectToolRefusal("invalid review or CI cost scope"); }
+  try { scope = cleanCostPlan(r); } catch (error) { throw new PreEffectToolRefusal(error instanceof CostScopeError ? error.message : "invalid review or CI cost scope"); }
   return { ...Object.fromEntries((profileData(profile).plan_keys as (keyof TaskPlan)[]).map((k) => [k, k === "paths" ? [...new Set(textList(r[k]).map(normPath))] : textList(r[k])] as const).filter(([, v]) => v.length)), ...evidence, ...scope };
 }
 
@@ -410,6 +432,7 @@ export interface ExperimentView { attempts: ExperimentAttemptView[]; counts: { a
   comparison?: { planHash: string; baselineAttemptId: string; variantAttemptId: string; approved: boolean; private: boolean; projection: ReturnType<typeof comparisonProjection> | "[pii]" } }
 interface ExperimentContext { task: Task; campaign: ResearchCampaignRecord; private: boolean; key: string; fence: ExperimentWriteFence }
 interface CompletionRefresh { revision: number; commit: string; state: "in_review" | "approved" }
+interface RefileHeadGuard { recorded?: string }
 interface IdentityLink { repo: string; pr: number; basis: { commit?: string; branch?: string } }
 
 /** What one live check of a task's files says as a whole (#317): `unchanged` only when EVERY file measured unchanged. A change outranks a missing file, which outranks one the hub could not read. */
@@ -563,7 +586,7 @@ export class Tasks {
       for (const task of this.d.board.list()) {
         if (this.d.sweepHeld?.() || this.d.bus.isRecoveryHeld || this.d.bus.storageError) break;
         if (!task.owner && this.personUnassigned(task)) continue;
-        const finding = nextSweep(task, config, now, this.waitsFor(task).length === 0);
+        const finding = nextSweep(task, config, now, this.waitsFor(task).length === 0 && !plannedStartPending(task, now));
         if (!finding || this.waitsFor(task).length || this.isChecking(task.id) || this.silentFor(task.id)) continue;
         if (finding.kind === "ready-unassigned") {
           this.d.board.update(task.id, HUB, "idle sweep", {}, undefined, { sweep: finding });
@@ -906,6 +929,8 @@ export class Tasks {
     if (rest.sdlc?.redFirst && !this.publicMetadataText(JSON.stringify(rest.sdlc.redFirst))) {
       const { redFirst: _withheld, ...receipt } = rest.sdlc; rest.sdlc = receipt;
     }
+    const currentSpecReport = this.currentSpecReport(task);
+    const currentSpecEntry = currentSpecReport ? history.findLast(entry => entry.event === "done" || entry.event === "done (checking)") : undefined;
     const screenHistoryText = (text: string, field: string, withheld = false): string => !withheld && this.nameable(text) ? text : `[history ${field} withheld: ${this.whyWithheld(text)}; ahub task show ${task.id}]`;
     const publicHistory = (fullHistory ? history : history.slice(-5)).map(h => ({
       at: h.at, by: h.by, event: h.event,
@@ -933,16 +958,23 @@ export class Tasks {
       ...(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 } : {}),
       ...(h.sweep ? { sweep: { kind: h.sweep.kind, activity: h.sweep.activity, step: h.sweep.step, at: h.sweep.at } } : {}),
+      ...(h === currentSpecEntry && currentSpecReport ? { specReport: currentSpecReport } : {}),
     }));
     const sets = this.reviewFindingSets(task), current = findingsForHead(sets, this.findingHead(task));
     const symbolRepository = codeSymbols && this.codeSymbolsRepository(task);
     const publicSymbols = codeSymbols && symbolRepository ? publicTaskCodeSymbols(codeSymbols, this.reviewHead(task), symbolRepository.key, this.publicMetadataText) : undefined;
     const handedOff = this.d.board.handoffOrigin(task.id);   // #604: where another project's handoff came from; two ids, never text
-    return { ...rest, ...(approvalBinding(task) ? { approval: approvalBinding(task) } : {}), ...(handedOff ? { handoffOrigin: { projectId: handedOff.projectId, peer: handedOff.peer, ...(handedOff.originTask === null ? {} : { task: handedOff.originTask }) } } : {}), ...(publicSymbols ? { codeSymbols: publicSymbols } : {}), ...(current.length ? { findings: findingTally(current) } : {}), ...(cancelled ? { cancelled: { ...cancelled, reason: screenHistoryText(cancelled.reason, "cancellation", cancelled.withheld), ...(cancelled.supersededBy ? { supersededBy: screenHistoryText(cancelled.supersededBy, "supersession", cancelled.withheld) } : {}) } } : {}), ...(external && this.nameable(external.url) ? { external } : {}), actualDates: actualTaskDates(task), ...(((this.d.sdlc?.config().mode ?? "off") !== "off" || this.d.sdlc?.config().workflow === "gsd-lite") ? { lifecycle: sdlcStatus(this.d.sdlc?.config() ?? sdlcConfig(undefined), task.sdlc, undefined, this.workflowView(task), undefined, sets, task.refs.commit) } : {}), title, detail, history: publicHistory };
+    return { ...rest, ...(currentSpecReport ? { specReport: currentSpecReport } : {}), ...(approvalBinding(task) ? { approval: approvalBinding(task) } : {}), ...(handedOff ? { handoffOrigin: { projectId: handedOff.projectId, peer: handedOff.peer, ...(handedOff.originTask === null ? {} : { task: handedOff.originTask }) } } : {}), ...(publicSymbols ? { codeSymbols: publicSymbols } : {}), ...(current.length ? { findings: findingTally(current) } : {}), ...(cancelled ? { cancelled: { ...cancelled, reason: screenHistoryText(cancelled.reason, "cancellation", cancelled.withheld), ...(cancelled.supersededBy ? { supersededBy: screenHistoryText(cancelled.supersededBy, "supersession", cancelled.withheld) } : {}) } } : {}), ...(external && this.nameable(external.url) ? { external } : {}), actualDates: actualTaskDates(task), ...(((this.d.sdlc?.config().mode ?? "off") !== "off" || this.d.sdlc?.config().workflow === "gsd-lite") ? { lifecycle: sdlcStatus(this.d.sdlc?.config() ?? sdlcConfig(undefined), task.sdlc, undefined, this.workflowView(task), undefined, sets, task.refs.commit) } : {}), title, detail, history: publicHistory };
   }
 
   /** Console results expose direct approval and delivery holds, not just the chosen peer ids. */
-  resultLine(task: Task): string {
+  specReportText(task: Task, by?: PeerId): string {
+    if (by && this.d.privateTurn?.(by)) return "";
+    const report = this.currentSpecReport(task);
+    return report ? renderSpecTaskReport(report) : "";
+  }
+
+  resultLine(task: Task, by?: PeerId): string {
     const base = `task #${task.id}: ${task.state}, owner ${task.owner ?? "none"}, reviewer ${task.reviewer ?? "none"}`;
     const noReview = task.class !== "review" && !task.reviewer && OPEN.includes(task.state) && !this.waitsFor(task).length
       ? this.noReviewer(assign(task, this.states(), this.d.routing(), { candidates: task.owner ? [task.owner] : [], notReviewer: task.owner ?? undefined, ...this.weights(task.class, task) }))
@@ -951,7 +983,250 @@ export class Tasks {
     const holdText = held ? `${task.owner}'s queue is held (${held}); it receives the task once the hold is resolved` : undefined;
     const request = task.history.findLast(entry => ["done", "reviewer changed", "reviewer unavailable"].includes(entry.event));
     const poolBlocked = task.state === "in_review" && task.reviewer === USER && request?.reviewBlocked ? "blocked: no reviewer can run" : undefined;
-    return [base, noReview, poolBlocked, holdText].filter(Boolean).join("; ");
+    const specText = this.specReportText(task, by) || undefined;
+    return [base, noReview, poolBlocked, holdText, specText].filter(Boolean).join("; ");
+  }
+
+  private currentSpecReport(task: Task): SpecTaskReport | undefined {
+    const config = this.d.specsConfig?.() ?? DEFAULT_SPECS_CONFIG;
+    if (this.isPii(task) || !config.enabled || config.review === "off") return;
+    const head = task.refs.commit && /^[0-9a-f]{40}$/.test(task.refs.commit) ? task.refs.commit : "";
+    const binding = this.specRefBinding(task);
+    const latest = task.history.findLast(row => row.event === "done" || row.event === "done (checking)");
+    const report = latest?.specReport;
+    if (!latest || !report || !(report.head === head || report.head === "" && !report.complete) || latest.specRefBinding !== binding) return;
+    return this.publicSpecReport(report);
+  }
+
+  private specRefBinding(task: Pick<Task, "refs">): string {
+    return createHash("sha256").update(JSON.stringify([task.refs.repo ?? "", task.refs.branch ?? "", task.refs.commit ?? ""])).digest("hex");
+  }
+
+  private publicSpecReport(report: SpecTaskReport): SpecTaskReport | undefined {
+    if (!report || typeof report.head !== "string" || report.head !== "" && !/^[0-9a-f]{40}$/.test(report.head)
+      || report.complete && !/^[0-9a-f]{40}$/.test(report.head)
+      || typeof report.complete !== "boolean" || !Number.isSafeInteger(report.errors) || report.errors < 0
+      || !Array.isArray(report.unchanged) || !Array.isArray(report.changed)) return;
+    const ref = (value: unknown): SpecTaskReport["unchanged"][number] | undefined => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return;
+      const row = value as Record<string, unknown>;
+      if (typeof row.id !== "string" || typeof row.path !== "string" || typeof row.title !== "string"
+        || !row.id.trim() || row.id.length > 160 || !row.path.trim()) return;
+      // Missing titles are schema diagnostics, not a report-mode completion gate.
+      const title = row.title.trim() ? row.title : row.id;
+      const strings = [row.id, row.path, title, ...(typeof row.reason === "string" ? [row.reason] : [])];
+      if (strings.some(text => text.length > 1000 || /[\p{Cc}\p{Cf}]/u.test(text) || !this.publicMetadataText(text))) return;
+      return { id: row.id, path: row.path, title, ...(typeof row.reason === "string" ? { reason: row.reason } : {}) };
+    };
+    const unchanged = report.unchanged.slice(0, 20).map(ref).filter((row): row is NonNullable<typeof row> => !!row);
+    const changed = report.changed.slice(0, 20).map(ref).filter((row): row is NonNullable<typeof row> => !!row);
+    const privacyFiltered = unchanged.length < Math.min(report.unchanged.length, 20) || changed.length < Math.min(report.changed.length, 20);
+    const reason = privacyFiltered ? "some spec metadata could not be safely shown"
+      : typeof report.reason === "string" && report.reason.length <= 500 && this.publicMetadataText(report.reason) ? report.reason : undefined;
+    return { head: report.head, complete: report.complete && !privacyFiltered, errors: report.errors, unchanged, changed,
+      ...(report.truncated || report.unchanged.length > 20 || report.changed.length > 20 ? { truncated: true } : {}), ...(reason ? { reason } : {}) };
+  }
+
+  private parseSpecAcks(value: unknown): SpecAck[] {
+    if (value === undefined) return [];
+    if (!Array.isArray(value) || value.length > 20) throw new PreEffectToolRefusal("spec_ack must contain at most 20 {id, reason} entries");
+    const seen = new Set<string>();
+    return value.map(raw => {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new PreEffectToolRefusal("each spec_ack entry needs an id and reason");
+      const row = raw as Record<string, unknown>;
+      if (Object.keys(row).some(key => key !== "id" && key !== "reason") || typeof row.id !== "string" || !row.id.trim() || row.id.length > 160 || /[\p{Cc}\p{Cf}]/u.test(row.id)
+        || typeof row.reason !== "string" || !row.reason.trim() || row.reason.length > 1000 || /[\p{Cc}\p{Cf}]/u.test(row.reason)) throw new PreEffectToolRefusal("each spec_ack entry needs a bounded id and reason");
+      const id = row.id.trim();
+      if (!this.publicMetadataText(id)) throw new PreEffectToolRefusal("spec_ack id is private or sensitive");
+      if (seen.has(id)) throw new PreEffectToolRefusal(`spec_ack repeats ${id}`);
+      seen.add(id);
+      return { id, reason: row.reason.trim() };
+    });
+  }
+
+  private specsPolicyKey(config = this.d.specsConfig?.() ?? DEFAULT_SPECS_CONFIG): string {
+    return JSON.stringify([config.enabled, config.review, config.roots, config.stamps_file]);
+  }
+
+  private assertSpecInspection(inspection: PreparedSpecInspection, task: Task, by: PeerId): void {
+    this.assertSpecTaskBinding(inspection, task);
+    if (this.specsPolicyKey() !== inspection.policyKey || (this.d.privateTurn?.(by) === true) !== inspection.privateTurn || this.isPii(task) !== inspection.pii) {
+      throw new PreEffectToolRefusal(`task #${task.id}: specs policy, task head or privacy context changed during inspection; retry hub_task_done`);
+    }
+  }
+
+  private assertSpecTaskBinding(inspection: PreparedSpecInspection, task: Task): void {
+    const head = task.refs.commit && /^[0-9a-f]{40}$/.test(task.refs.commit) ? task.refs.commit : "";
+    if (task.refs.repo !== inspection.repo || head !== inspection.head) {
+      throw new PreEffectToolRefusal(`task #${task.id}: task head or repository changed during spec inspection; retry hub_task_done`);
+    }
+  }
+
+  private refreshAsyncSpecInspection(inspection: PreparedSpecInspection, task: Task, by: PeerId): boolean {
+    this.assertSpecTaskBinding(inspection, task);
+    const config = this.d.specsConfig?.() ?? DEFAULT_SPECS_CONFIG;
+    const privateTurn = this.d.privateTurn?.(by) === true;
+    const policyKey = this.specsPolicyKey(config), pii = this.isPii(task);
+    if (inspection.report && policyKey !== inspection.policyKey && config.enabled && config.review === "require" && !privateTurn && !pii) return true;
+    if (policyKey !== inspection.policyKey || privateTurn !== inspection.privateTurn || pii !== inspection.pii) {
+      delete inspection.report;
+      inspection.policyKey = policyKey;
+      inspection.privateTurn = privateTurn;
+      inspection.pii = pii;
+    }
+    return false;
+  }
+
+  private requestSpecRefile(task: Task): void {
+    this.tell(task, `Task #${task.id}: its class check passed, but specs policy changed to require while it ran. Refile hub_task_done so coverage is checked under the current policy.`, this.isPii(task));
+  }
+
+  private specInspectionReason(cause: string): string {
+    const safe = this.publicMetadataText(cause) ? sanitize(cause).replace(/[\r\n\t]+/g, " ").trim().slice(0, 350) : "verified spec evidence is unavailable";
+    return `${safe}; split the task scope or ask the person to change specs.review`;
+  }
+
+  private async inspectTaskSpecs(task: Task, by: PeerId, rawAcks: unknown, validate: () => Task): Promise<PreparedSpecInspection> {
+    const config = this.d.specsConfig?.() ?? DEFAULT_SPECS_CONFIG;
+    const initialPrivate = this.d.privateTurn?.(by) === true, pii = this.isPii(task);
+    const declaredHead = task.refs.commit && /^[0-9a-f]{40}$/.test(task.refs.commit) ? task.refs.commit : "";
+    const inspection: PreparedSpecInspection = { policyKey: this.specsPolicyKey(config), ...(task.refs.repo ? { repo: task.refs.repo } : {}), head: declaredHead, privateTurn: initialPrivate, pii };
+    const ackInput = Array.isArray(rawAcks) && rawAcks.length === 0 ? undefined : rawAcks;
+    if (ackInput !== undefined && (pii || initialPrivate)) throw new PreEffectToolRefusal("spec_ack is unavailable for private work");
+    if (ackInput !== undefined && (!config.enabled || config.review === "off")) throw new PreEffectToolRefusal("spec_ack is unavailable while specs review is disabled");
+    if (!config.enabled || config.review === "off" || pii || initialPrivate) return inspection;
+    if (!this.d.inspectSpecs) {
+      if (config.review === "require" && declaredHead) throw new PreEffectToolRefusal(`task #${task.id}: spec coverage is unknown because the spec inspector is unavailable at the submitted head; restore specs support or explicitly change specs.review`);
+      if (ackInput !== undefined) throw new PreEffectToolRefusal("spec inspection is unavailable; cannot accept spec_ack");
+      return inspection;
+    }
+    const acks = this.parseSpecAcks(ackInput);
+    let changedFiles: BriefFile[] | undefined;
+    let changedEvidenceReason: string | undefined;
+    if (declaredHead) {
+      const brief = this.d.reviewBrief?.({ ...task, refs: { ...task.refs, commit: declaredHead } });
+      if (!brief) changedEvidenceReason = "the verified review brief is unavailable";
+      else if ("unavailable" in brief) changedEvidenceReason = `review brief unavailable: ${brief.unavailable}`;
+      else if (brief.head !== declaredHead) changedEvidenceReason = "the verified review brief does not match the submitted full head";
+      else if (brief.withheld > 0) changedEvidenceReason = `the verified review brief withheld ${brief.withheld} changed file(s)`;
+      else if (brief.unlisted.length > 0) changedEvidenceReason = `the verified review brief has ${brief.unlisted.length} unlisted changed file(s)`;
+      else {
+        const files = [...brief.reviewable, ...brief.excluded].flatMap(file => [file, ...(file.oldPath ? [{ path: file.oldPath, status: file.status }] : [])]);
+        if (files.every(file => this.publicMetadataText(file.path))) {
+          const byPath = new Map<string, BriefFile>();
+          for (const file of files) if (!byPath.has(file.path)) byPath.set(file.path, file);
+          changedFiles = [...byPath.values()];
+        } else changedEvidenceReason = "the verified changed-file inventory includes private paths";
+      }
+    } else changedEvidenceReason = "a full task commit head was not supplied";
+    const screenedAcks: SpecAck[] = [];
+    for (const ack of acks) {
+      if (!this.publicMetadataText(ack.reason)) throw new PreEffectToolRefusal("spec_ack reason is private or sensitive");
+      if (await this.withholds("note", ack.reason, task)) throw new PreEffectToolRefusal(`spec_ack reason for ${ack.id} was withheld; use a public, non-sensitive rationale`);
+      screenedAcks.push(ack);
+      this.assertSpecInspection(inspection, validate(), by);
+    }
+    this.assertSpecInspection(inspection, validate(), by);
+    const report = await this.d.inspectSpecs(task, declaredHead, changedFiles, screenedAcks);
+    this.assertSpecInspection(inspection, validate(), by);
+    if (!report) {
+      if (acks.length) throw new PreEffectToolRefusal("spec_ack was supplied but no spec requires acknowledgement");
+      return inspection;
+    }
+    const safe = this.publicSpecReport(report);
+    if (!safe) throw new PreEffectToolRefusal("spec inspection returned invalid or private metadata");
+    if (safe.unchanged.length < Math.min(report.unchanged.length, 20) || safe.changed.length < Math.min(report.changed.length, 20)) {
+      safe.complete = false;
+      safe.reason = this.specInspectionReason("some spec metadata could not be safely shown");
+    }
+    if (safe.head !== declaredHead) {
+      safe.complete = false;
+      safe.head = "";
+      safe.reason = this.specInspectionReason("the spec report does not match the verified task head");
+      safe.unchanged = [];
+      safe.changed = [];
+    }
+    if (report.truncated) {
+      safe.complete = false;
+      safe.reason = this.specInspectionReason("the submitted spec scan reached its safety limit; narrow specs.roots");
+    } else if (changedFiles === undefined && changedEvidenceReason && safe.head === declaredHead) {
+      safe.complete = false;
+      safe.reason = this.specInspectionReason(changedEvidenceReason);
+    } else if (!safe.complete && safe.reason) safe.reason = this.specInspectionReason(safe.reason);
+    else if (!safe.complete) safe.reason = this.specInspectionReason(report.reason ?? "spec coverage could not be verified at the submitted task head");
+    if (config.review === "require" && report.unchanged.length > 20) throw new PreEffectToolRefusal(`task #${task.id}: ${report.unchanged.length} covering specs are unchanged; update the specs or split the task scope so each task covers at most 20 specs`);
+    const pendingIds = new Set(safe.unchanged.map(spec => spec.id));
+    for (const ack of screenedAcks) if (!pendingIds.has(ack.id)) throw new PreEffectToolRefusal(`spec_ack ${ack.id} does not name a covering spec that is unchanged at this head`);
+    const reasons = new Map(screenedAcks.map(ack => [ack.id, ack.reason]));
+    safe.unchanged = safe.unchanged.map(spec => ({ ...spec, ...(reasons.has(spec.id) ? { reason: reasons.get(spec.id)! } : {}) }));
+    if (config.review === "require") {
+      if (!safe.complete || report.truncated) throw new PreEffectToolRefusal(`task #${task.id}: ${safe.reason ?? this.specInspectionReason("spec coverage is unknown at this submitted task head")}`);
+      const unacknowledged = safe.unchanged.filter(spec => !reasons.has(spec.id));
+      if (unacknowledged.length) throw new PreEffectToolRefusal(`task #${task.id}: spec not updated: ${unacknowledged.map(spec => spec.id).join(", ")}; update the covering spec or add spec_ack [{id, reason}]`);
+    }
+    inspection.report = safe;
+    return inspection;
+  }
+
+  /** Narrow public task-path notice used by the tool response after propose/accept. */
+  specNotice(task: Task, by?: PeerId): string {
+    const config = this.d.specsConfig?.() ?? DEFAULT_SPECS_CONFIG;
+    if (!config.enabled || config.review === "off" || this.isPii(task) || by && this.d.privateTurn?.(by)) return "";
+    let report: SpecsCoverReport | undefined;
+    try { report = this.d.specNotice?.(task); } catch { return ""; }
+    const current = this.d.board.get(task.id);
+    if (!current || this.isPii(current) || by && this.d.privateTurn?.(by)
+      || current.history.length !== task.history.length || current.owner !== task.owner || current.refs.repo !== task.refs.repo
+      || JSON.stringify(current.refs.paths ?? []) !== JSON.stringify(task.refs.paths ?? [])) return "";
+    if (!report) return "";
+    const refs = report.specs.slice(0, 20).filter(spec => [spec.id, spec.path, spec.title].every(value => this.publicMetadataText(value)));
+    const lines = refs.length ? [`Specs covering these paths: ${refs.map(spec => `${spec.id} (${spec.path})`).join(", ")}`] : [];
+    if (report.errors) lines.push(`Spec coverage check reports ${report.errors} error${report.errors === 1 ? "" : "s"}; run ahub specs check.`);
+    if (report.truncated || report.specs.length > 20 || refs.length < Math.min(report.specs.length, 20)) lines.push("Spec coverage list truncated; run ahub specs covers for the full list.");
+    return sanitize(lines.join("\n"));
+  }
+
+  specsRead(by: PeerId, action: "check" | "covers", rawPaths: unknown = []): Record<string, unknown> {
+    if (this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("spec inspection unavailable during a private turn");
+    if (!this.d.specsRead) throw new PreEffectToolRefusal("spec inspection unavailable");
+    if (action !== "check" && action !== "covers") throw new PreEffectToolRefusal('hub_specs action must be "check" or "covers"');
+    if (!Array.isArray(rawPaths) || rawPaths.length > 32 || rawPaths.some(path => typeof path !== "string" || !path.trim() || path.length > 2000 || /[\p{Cc}\p{Cf}]/u.test(path)
+      || path.startsWith("/") || path.includes("\\") || path.split("/").includes("..") || !this.publicMetadataText(path))) throw new PreEffectToolRefusal("hub_specs paths must be bounded, public repository-relative paths using forward slashes");
+    const paths = rawPaths as string[];
+    if (action === "check" && paths.length) throw new PreEffectToolRefusal('hub_specs "check" takes no paths');
+    if (action === "covers" && paths.length === 0) throw new PreEffectToolRefusal('hub_specs "covers" needs at least one repository-relative path');
+    const safe = (value: string) => sanitize(value);
+    const diagnostic = (raw: SpecsCheckReport["items"][number]): Record<string, unknown> | undefined => {
+      const fields = [raw.code, raw.message, raw.cause, raw.nextSteps, ...(raw.path ? [raw.path] : []), ...(raw.id ? [raw.id] : []), ...(raw.field ? [raw.field] : []), ...(raw.relatedId ? [raw.relatedId] : [])];
+      if (fields.some(value => !this.publicMetadataText(value))) return;
+      return { severity: raw.severity, code: safe(raw.code), message: safe(raw.message), cause: safe(raw.cause), nextSteps: safe(raw.nextSteps),
+        ...(raw.path ? { path: safe(raw.path) } : {}), ...(raw.id ? { id: safe(raw.id) } : {}), ...(raw.field ? { field: safe(raw.field) } : {}), ...(raw.relatedId ? { relatedId: safe(raw.relatedId) } : {}) };
+    };
+    let report: SpecsCheckReport | SpecsCoverReport;
+    try { report = this.d.specsRead(action, paths); }
+    catch { throw new PreEffectToolRefusal("spec inspection unavailable; retry ahub specs check"); }
+    if (this.d.privateTurn?.(by)) throw new PreEffectToolRefusal("spec inspection unavailable during a private turn");
+    try {
+      if ("freshness" in report) {
+        const visibleItems = report.items.map(diagnostic).filter((row): row is Record<string, unknown> => !!row);
+        const items = visibleItems.slice(0, 20);
+        const remaining = Math.max(0, 20 - items.length);
+        const visibleFreshness = report.freshness.filter(row => this.publicMetadataText(row.path) && (row.id === undefined || this.publicMetadataText(row.id)));
+        const freshness = visibleFreshness.slice(0, remaining)
+          .map(row => ({ path: safe(row.path), ...(row.id ? { id: safe(row.id) } : {}), state: row.state, commitsSince: row.commitsSince, dirty: row.dirty }));
+        return { specCount: report.specCount, errors: report.errors, warnings: report.warnings, stale: report.stale,
+          truncated: report.truncated || visibleItems.length > 20 || visibleItems.length !== report.items.length
+            || visibleFreshness.length > freshness.length || visibleFreshness.length !== report.freshness.length, freshness, items };
+      }
+      const visibleSpecs = report.specs.filter(row => [row.id, row.path, row.title].every(value => this.publicMetadataText(value)));
+      const specs = visibleSpecs.slice(0, 20)
+        .map(({ id, path, title }) => ({ id: safe(id), path: safe(path), title: safe(title) }));
+      const visibleItems = report.items.map(diagnostic).filter((row): row is Record<string, unknown> => !!row);
+      const remaining = Math.max(0, 20 - specs.length);
+      const items = visibleItems.slice(0, remaining);
+      return { specs, errors: report.errors, truncated: report.truncated || visibleSpecs.length > specs.length || visibleSpecs.length !== report.specs.length
+        || visibleItems.length > remaining || visibleItems.length !== report.items.length, items };
+    } catch { throw new PreEffectToolRefusal("spec inspection unavailable; retry ahub specs check"); }
   }
 
   private states(): Record<PeerId, PeerState> {
@@ -1064,6 +1339,38 @@ export class Tasks {
 
   private reviewHead(task: Task): string | undefined { return task.refs.commit ?? task.sdlc?.head ?? task.sdlc?.localHead; }
 
+  private recordedReviewHead(task: Task): string | undefined {
+    const isFullHead = (value: unknown): value is string => typeof value === "string" && /^[a-f0-9]{40}$/.test(value);
+    const historyHead = task.history.findLast(entry => (entry.event === "approved" || entry.event === "changes_requested") && isFullHead(entry.reviewedHead))?.reviewedHead;
+    return [task.sdlc?.reviewedHead, historyHead].find(isFullHead);
+  }
+
+  /** An owner ref, when present, outranks host-derived receipt.head values for review identity. */
+  private ownerReviewHead(task: Task): string | undefined {
+    return /^[a-f0-9]{40}$/.test(task.refs.commit ?? "") ? task.refs.commit : this.recordedReviewHead(task);
+  }
+
+  private hasReviewHistory(task: Task): boolean {
+    return task.state === "changes_requested" || !!task.sdlc?.reviewedHead || task.history.some(entry => entry.event === "approved" || entry.event === "changes_requested");
+  }
+
+  private reviewHeadMoveRefusal(taskId: number, recorded: string | undefined, current?: string): PreEffectToolRefusal {
+    const known = recorded ? `recorded review head ${recorded}` : "a recorded full review head";
+    const cause = current ? `${known} differs from current head of PR ${current}`
+      : `current PR head could not be verified against ${known}`;
+    const next = current ? `refs.commit set to ${current}` : "refs.commit set to the current full SHA";
+    return new PreEffectToolRefusal(`task #${taskId}: ${cause}; owner must re-file hub_task_done with ${next} before review`);
+  }
+
+  private async currentPrHeadForReview(task: Task, validate: () => Task): Promise<string | undefined> {
+    const receipt = task.sdlc, gh = this.d.sdlc?.gh;
+    if (this.isPii(task) || !receipt?.repo || !receipt.pr || !gh) return undefined;
+    const identity = (value: Task) => JSON.stringify([value.id, value.state, value.owner, value.reviewer, value.history.length, this.isPii(value), value.refs, value.sdlc]);
+    const before = identity(task), head = await readSdlcPrHead(receipt, gh), current = validate();
+    if (identity(current) !== before) throw new PreEffectToolRefusal(`task #${task.id}: task or review head changed during PR readback; reload and retry`);
+    return head;
+  }
+
   private reviewPoolOptions(task: Task) {
     const head = this.reviewHead(task);
     const round = task.state === "in_review" ? task.history.slice(task.history.findLastIndex(entry => entry.event === "done") + 1) : [];
@@ -1100,6 +1407,27 @@ export class Tasks {
     return { ...(family ? { reviewerFamily: family } : {}), ...(reason ? { reviewerReason: reason } : {}), ...(assignment?.reviewBlocked ? { reviewBlocked: true } : {}), ...(queueReviewHeld ? { queueReviewHeld: true as const, ...(queueReviewBinding !== undefined ? { queueReviewBinding } : {}) } : {}) };
   }
 
+  /**
+   * #1081: a task that declares `needs_network` or `needs_worktree` is refused at accept when its owner cannot meet the need, before any write. Routing
+   * already keeps such a task away from that peer; this covers an offer made before the sandbox network was switched off, and it is what stops a
+   * sandboxed peer from accepting work, failing at `git worktree add` (#270) and leaving an empty branch ref behind (#621, #565). Unknown capability is
+   * not a refusal, and a PII task skips the check as `requireCapabilities` does.
+   */
+  private declaredNeedCheck(task: Pick<Task, "signals" | "id"> & Partial<Pick<Task, "signals" | "class">>, peer: PeerId): void {
+    if (!this.d.capabilities || this.isPii(task as Task)) return;
+    // #1129: write-class work needs the hub's worktree whether or not it says so, because a hub-sandboxed owner cannot commit.
+    const declaredWorktree = task.signals?.includes("needs_worktree") === true;
+    const wantsNetwork = task.signals?.includes("needs_network") === true, wantsWorktree = declaredWorktree || (task.class !== undefined && writesRepository(task.class));
+    if (!wantsNetwork && !wantsWorktree) return;
+    const caps = peerEntry(this.d.capabilities(), peer);
+    if (wantsNetwork && caps?.network === false) {
+      throw new PreEffectToolRefusal(`task #${task.id} needs the network and ${peer} has none: ${caps.networkReason ?? "its shell cannot reach the network"}; decline it so the hub offers it to a peer with network, or ask the person to enable it`);
+    }
+    if (wantsWorktree && caps?.worktree === false) {
+      throw new PreEffectToolRefusal(`task #${task.id} ${declaredWorktree ? "needs its own git worktree" : "changes the repository, so the hub must make its git worktree and commit for it"} and ${peer} cannot create one: ${caps.worktreeReason ?? "it cannot create the task worktree"}; nothing was created, so no branch ref is left behind; decline it so the hub offers it to a peer that can, this will not change by waiting`);
+    }
+  }
+
   /** 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);
@@ -1108,7 +1436,7 @@ export class Tasks {
     if ((!this.d.capabilities || this.isPii(task)) && !declaredExtra) return;
     const { state: _state, ...draft } = task; // backlog/readiness must not bypass an explicit reservation's admission
     const admission = assign(draft, this.states(), this.d.routing(), { candidates: role === "owner" ? [peer] : [], ...(role === "owner" ? { namedOwner: peer } : { namedReviewer: peer }), ...this.weights(task.class) });
-    const missing = (admission.refusals ?? []).filter(row => row.peer === peer && row.role === role && (row.code === "tests" || row.code === "spec" || declaredExtra && role === "owner" && row.code === "owner-admission")).map(row => `  ${role} candidate ${peer}: skipped, ${row.reason}`);
+    const missing = (admission.refusals ?? []).filter(row => row.peer === peer && row.role === role && (row.code === "tests" || row.code === "spec" || row.code === "network" || row.code === "worktree" || declaredExtra && role === "owner" && row.code === "owner-admission")).map(row => `  ${role} candidate ${peer}: skipped, ${row.reason}`);
     if (missing.length) throw new (preEffect ? PreEffectToolRefusal : Error)(`cannot assign ${peer}: ${missing.join("; ")}`);
   }
 
@@ -2188,6 +2516,7 @@ export class Tasks {
   /** Write-driven wake-ups (#785): one unsettled ids-only task notice per planner, never a polling pull. */
   private writePlannerNotices(task: Task, before: ReadonlyMap<PeerId, number>, approved = false): void {
     this.releaseNotice(`task #${task.id}: could not notify planner about ready work`, () => {
+      const now = this.d.now?.() ?? Date.now();
       const changes = new Map<PeerId, { capacity: Set<PeerId>; ready: Set<number> }>();
       const add = (planner: PeerId, peer?: PeerId, id?: number) => {
         if (!this.d.bus.isRostered(planner)) return;
@@ -2199,7 +2528,7 @@ export class Tasks {
       const released = new Set<PeerId>();
       for (const [peer, used] of before) if (this.wip(peer) < used) { released.add(peer); for (const planner of this.taskPlanner(task)) add(planner, peer); }
       if (approved) for (const card of this.d.board.list("backlog")) {
-        if (card.deps?.includes(task.id) && !this.waitsFor(card).length) for (const planner of this.taskPlanner(card)) add(planner, undefined, card.id);
+        if (card.deps?.includes(task.id) && !this.waitsFor(card).length && !plannedStartPending(card, now)) for (const planner of this.taskPlanner(card)) add(planner, undefined, card.id);
       }
       for (const [planner, change] of changes) this.releaseNotice(`could not notify planner ${planner} about ready work`, () => {
         const pending = this.d.bus.pendingEnvelopes(planner).filter(env => env.from === HUB && env.kind === "task" && env.body.startsWith("Planner work ready:"));
@@ -2217,7 +2546,7 @@ export class Tasks {
         }
         for (const id of change.ready) {
           const card = this.d.board.get(id);
-          if (card?.state === "backlog" && this.taskPlanner(card).includes(planner) && !this.waitsFor(card).length) lines.push(`backlog_ready: #${id}`);
+          if (card?.state === "backlog" && this.taskPlanner(card).includes(planner) && !this.waitsFor(card).length && !plannedStartPending(card, now)) lines.push(`backlog_ready: #${id}`);
           else change.ready.delete(id);
         }
         for (const env of pending) this.d.bus.withdraw(env.id);
@@ -2231,8 +2560,9 @@ 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 {
+    const now = this.d.now?.() ?? Date.now();
     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 && !card.draft && taskCanPlan(card) && !this.waitsFor(card).length && !this.excluded(card).includes(peer)
+      && (planner === undefined || this.taskPlanner(card).includes(planner)) && !plannedStartPending(card, now) && !(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];
   }
 
@@ -2264,10 +2594,15 @@ export class Tasks {
     if (!planner || !this.d.bus.isRostered(planner)) return;
     const reason = `auto_pull: capacity released for ${peer}; hub acted for planner ${planner}`;
     try {
-      await this.pullPlanned(HUB, { id: card.id, revision: card.planningRevision ?? 0, reason }, { onBehalfOf: planner, guard: () => { if (!this.autoPullAdmitted()) throw new PreEffectToolRefusal("auto pull is no longer admitted: tasks.auto_pull was turned off or a recovery, shutdown or storage hold began"); } });
+      await this.pullPlanned(HUB, { id: card.id, revision: card.planningRevision ?? 0, reason }, { onBehalfOf: planner, guard: () => {
+        if (!this.autoPullAdmitted()) throw new PreEffectToolRefusal("auto pull is no longer admitted: tasks.auto_pull was turned off or a recovery, shutdown or storage hold began");
+        const current = this.d.board.get(card.id);
+        if (current && plannedStartPending(current, this.d.now?.() ?? Date.now())) throw new PreEffectToolRefusal("auto pull is waiting for the planned start");
+      } });
     } catch (e) {
       // A guard refusal is the setting or a hold doing its job, not a failure to report.
-      if (!this.autoPullAdmitted()) return;
+      const current = this.d.board.get(card.id);
+      if (!this.autoPullAdmitted() || current && plannedStartPending(current, this.d.now?.() ?? Date.now())) return;
       this.releaseNotice(`task ${this.publicTitle(card)}: auto_pull for ${peer} refused: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
@@ -2982,7 +3317,7 @@ 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; draft?: unknown; goal?: unknown }, external?: GitHubSource, created?: () => void, fence?: () => string | undefined): Promise<Task> {
+  async propose(by: PeerId, input: { title?: string; detail?: string; class?: string; role?: unknown; refs?: TaskRefs; plan?: TaskPlan; owner?: PeerId; after?: unknown; urgent?: unknown; needs_network?: unknown; needs_worktree?: 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;
@@ -3026,6 +3361,12 @@ export class Tasks {
     const signals = this.signalsFor({ ...text, detail: [screenDetail, planText(plan)].join("\n"), plan });
     // Urgent work is handed over even when its paused owner's window resets soon (issue #36).
     if (input.urgent === true && !signals.includes("urgent")) signals.push("urgent");
+    // #1081: a declared need is a signal like urgent, so routing and every later capability check read the same field. Only an explicit true sets it.
+    if (input.needs_network !== undefined && typeof input.needs_network !== "boolean") throw new PreEffectToolRefusal("needs_network must be true or false; omit it when the work needs no network");
+    if (input.needs_network === true && !signals.includes("needs_network")) signals.push("needs_network");
+    // #1081 (amended AC1): the same for a task worktree. Only an explicit true sets it.
+    if (input.needs_worktree !== undefined && typeof input.needs_worktree !== "boolean") throw new PreEffectToolRefusal("needs_worktree must be true or false; omit it when the work needs no task worktree");
+    if (input.needs_worktree === true && !signals.includes("needs_worktree")) signals.push("needs_worktree");
     // The PII screen (issue #198) reads the same text before anything else does: until its verdict the task is on no
     // board, in no envelope and before no other model. A pattern match is PII without a call; no verdict is PII too.
     const screening = this.screenOn();
@@ -3599,6 +3940,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; 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 (by === HUB && !task.owner && ["backlog", "proposed"].includes(task.state) && plannedStartPending(task, this.d.now?.() ?? Date.now())) throw new PreEffectToolRefusal("planned start is in the future");
     if (task.state === "backlog" && !opts.plannerPull) throw new PreEffectToolRefusal(`task #${task.id}: pull backlog work before assigning it`);
     const studyReason = this.studyDispatchReason(task, opts.namedOwner);
     if (studyReason) {
@@ -3616,6 +3958,7 @@ export class Tasks {
         if (opts.plannerPull) throw new PreEffectToolRefusal("planner pull changed during admission");
         return current ?? task;
       }
+      if (by === HUB && !current.owner && ["backlog", "proposed"].includes(current.state) && plannedStartPending(current, this.d.now?.() ?? Date.now())) throw new PreEffectToolRefusal("planned start is in the future");
       task = current; // Reviewer-only and quiet bookkeeping updates do not supersede ownership authority.
       if (gap) {
         this.requestIndependentPlanReview(current);
@@ -3673,7 +4016,9 @@ export class Tasks {
     const binding = this.plannerBinding(task, a, !!opts.plannerPull);
     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?.();
-    this.studyDispatchCheck(this.d.board.get(task.id) ?? task, a.owner);
+    const current = this.d.board.get(task.id) ?? task;
+    if (by === HUB && !current.owner && ["backlog", "proposed"].includes(current.state) && plannedStartPending(current, this.d.now?.() ?? Date.now())) throw new PreEffectToolRefusal("planned start is in the future");
+    this.studyDispatchCheck(current, a.owner);
     const next = opts.plannerPull
       ? this.d.board.pullAssigned(task.id, by, a.owner, opts.plannerPull.revision, opts.plannerPull.note, opts.plannerPull.withheld, a.reviewer ?? null, assignmentNote, assignmentExtra, task.history.length, 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);
@@ -3737,7 +4082,17 @@ export class Tasks {
       }
       if (stagedClaimGap) return next; // An explicit claim may reserve its owner, but no offer or acceptance bypasses review.
       this.studyDispatchCheck(next, by);
-      const claimed = this.d.board.update(next.id, by, "accepted", { state: "in_progress" });
+      // #1129: a self-claim of write-class work is an accept too, so a hub-sandboxed claimant gets the hub's worktree here, before the write. When the hub cannot make one the claim stays an assignment, like the missing-spec case above: `hub_task_accept` starts it and refuses with the same cause.
+      let undoWorktree: (() => void) | undefined;
+      try { undoWorktree = this.hubWorktreeFor(next, by); }
+      catch (error) {
+        if (!(error instanceof PreEffectToolRefusal)) throw error;
+        this.releaseNotice(`${error.message}; the claim stays assigned to ${by} and is not started`);
+        return next;
+      }
+      let claimed: Task;
+      try { claimed = this.d.board.update(next.id, by, "accepted", { state: "in_progress" }); }
+      catch (error) { undoWorktree?.(); throw error; }
       this.captureOwnerAcceptance(claimed);
       this.releaseNotice(`task ${this.publicTitle(claimed)} claimed by ${by}`);
       return claimed;
@@ -3773,7 +4128,8 @@ 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) : "";
+    // #1129: a claim by a hub-sandboxed peer carries the worktree note as an accept does, since the claim result is all it reads.
+    return task.owner === peer && task.state === "in_progress" ? [this.roleGuidance(task, peer), this.worktreeNote(task, peer)].filter(Boolean).join("\n") : "";
   }
 
   private roleGuidance(task: Task, peer: PeerId, review = false): string {
@@ -4038,6 +4394,12 @@ export class Tasks {
         if (!this.queuePressureAdmitted()) return;
         const task = this.d.board.get(stall.task);
         if (!this.ordinaryQueueProposal(stall, task)) { this.d.board.clearStall(stall.task); continue; }
+        if (plannedStartPending(task, this.d.now?.() ?? Date.now())) {
+          const scheduledOrigin = this.d.board.queuePressureStallPage(task.id - 1, 1).rows.find(row => row.task === task.id);
+          if (scheduledOrigin) this.d.board.recordStall({ ...scheduledOrigin, replanRevision: task.planningRevision ?? 0 });
+          pass.retained = true;
+          continue;
+        }
         // A planning revision asks for fresh admission, never erases an automatic offer.
         const namedOwner = stall.cause.peer;
         const retry = namedOwner ? { candidates: [namedOwner], namedOwner } : {};
@@ -4180,6 +4542,7 @@ export class Tasks {
     const capacity = this.capacityBefore(task);
     this.ciWatchers.cancel(task.id); this.heldReviews.delete(task.id);
     const next = this.d.board.update(task.id, by, "cancelled", { state: "cancelled", reserved: null, cancelled }, cancelled.reason, { ...(withheld ? { withheld: true as const } : {}) }, revision);
+    this.releaseHubWorktree(task, task.owner);
     this.writePlannerNotices(next, capacity);
     this.releaseNotice(`task #${task.id}: cancellation cohort cleanup unavailable`, () => this.cohorts.leave(task.id));
     this.offered.delete(task.id);
@@ -4203,6 +4566,7 @@ export class Tasks {
   }
 
   async releaseReady(): Promise<void> {
+    const now = this.d.now?.() ?? Date.now();
     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; }
@@ -4214,6 +4578,7 @@ export class Tasks {
         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; }
       }
+      if (plannedStartPending(t, now)) 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) {
         // A diagnostic legacy pass is not evidence that an automatic proposal was attempted.
@@ -4235,6 +4600,7 @@ export class Tasks {
     try {
       const t = this.d.board.get(stale.id);
       if (!t || t.state !== "proposed" || t.owner || this.personUnassigned(t) || this.offered.has(t.id)) return;
+      if (plannedStartPending(t, this.d.now?.() ?? Date.now())) return;
       const planned = this.plannerPullRecord(t)?.pull === true;
       const selected = planned ? this.plannerAssignment(t, true).owner : undefined;
       if (planned && !selected) return;
@@ -4251,6 +4617,7 @@ export class Tasks {
     } 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.
+      if (e instanceof PreEffectToolRefusal && e.message === "planned start is in the future") return;
       if (e instanceof AssignmentUndeliveredError) undelivered = e;
       else this.releaseNotice(`task ${this.publicTitle(stale)}: could not be assigned: ${e instanceof Error ? e.message : String(e)}`);
     } finally {
@@ -4419,7 +4786,7 @@ export class Tasks {
       if (!result.owner) for (const refusal of result.refusals ?? []) if (refusal.role === "owner") blockers.push({ task: task.id, code: refusal.code === "instance" || refusal.code === "family" ? "policy" : refusal.code });
       if (this.waitsFor(task).length) blockers.push({ task: task.id, code: "dependency" });
     }
-    const digest = plannerGrooming(visible, { dependencies, dependencyTruncated, repository: this.d.repository ?? `path:${realPath(this.d.cwd)}`,
+    const digest = plannerGrooming(visible, { dependencies, dependencyTruncated, repository: this.d.repository ?? `path:${realPath(this.d.cwd)}`, now: this.d.now?.() ?? Date.now(),
       limits: Object.fromEntries(peers.map(peer => [peer, this.wipLimit(peer)])), wip: Object.fromEntries(peers.map(peer => [peer, this.wip(peer)])),
       states, issues, reviewedIssues, acceptedIssues, blockers });
     return { ...digest, truncated: digest.truncated || incomplete, ...(current.some(task => this.isPii(task)) ? { privateTasks: "withheld" } : {}) };
@@ -4819,8 +5186,8 @@ export class Tasks {
     if (isClosedTaskState(task.state)) throw new PreEffectToolRefusal("closed work is final");
     if ((task.planningRevision ?? 0) !== revision) throw new PreEffectToolRefusal("planning revision changed");
     let scope: CostPlan;
-    try { scope = cleanCostPlan({ ...task.plan, ...("review" in raw ? { review: raw.review } : {}), ...("ci" in raw ? { ci: raw.ci } : {}) }); }
-    catch { throw new PreEffectToolRefusal("invalid review or CI cost scope"); }
+    try { scope = cleanCostPlan({ ...task.plan, ...("review" in raw ? { review: raw.review } : {}), ...("ci" in raw ? { ci: raw.ci } : {}) }, { review: "review" in raw ? "" : "plan", ci: "ci" in raw ? "" : "plan" }); }
+    catch (error) { throw new PreEffectToolRefusal(error instanceof CostScopeError ? error.message : "invalid review or CI cost scope"); }
     const mode = (this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode;
     if (!scope.review || !scope.ci) {
       if (mode === "enforce") throw new PreEffectToolRefusal("review and CI cost scope required for a new plan receipt");
@@ -5331,10 +5698,18 @@ export class Tasks {
 
   /** 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> {
+  private async lifecycleGate(task: Task, transition: "review" | "approval", reviewedHead?: string, findings?: readonly ReviewFindingSet[], refileHead?: RefileHeadGuard): Promise<PrEvidence | undefined> {
     const config = this.d.sdlc?.config() ?? sdlcConfig(undefined);
     if (config.mode === "off") return;
     const receipt = task.sdlc && { ...task.sdlc, ...(reviewedHead ? { reviewedHead } : {}) };
+    const approvalHead = transition === "approval" ? reviewedHead ?? this.ownerReviewHead(task) ?? this.findingHead(task) : undefined;
+    const guardedHead = !!refileHead || !!approvalHead && !!receipt?.repo && !!receipt.pr && !this.isPii(task);
+    // Compare raw head identity on both sides; `task` may carry an uncommitted identityLink.
+    // Completion state/history races stay with completionCurrent's existing post-readback fence.
+    const identity = (value: Task) => JSON.stringify([value.id, value.owner, value.reviewer, this.isPii(value),
+      value.refs.repo, value.refs.commit, value.refs.branch, value.sdlc?.repo, value.sdlc?.pr,
+      value.sdlc?.head, value.sdlc?.localHead, value.sdlc?.reviewedHead]);
+    const beforeHeadRead = guardedHead ? identity(this.need(task.id, false, true)) : undefined;
     const deadline = performance.now() + 20_000;
     const read: SdlcGh = (args, timeout, cwd, cap) => {
       const current = this.need(task.id, false, true);
@@ -5343,6 +5718,16 @@ export class Tasks {
       return remaining > 0 ? (this.d.sdlc?.gh ?? sdlcGh)(args, Math.min(timeout ?? 10_000, remaining), cwd, cap) : Promise.resolve({ code: 1, stdout: "" });
     };
     const evidence = receipt && !this.isPii(task) ? await readSdlcPr(receipt, read, true) : undefined;
+    const currentHead = receipt && !this.isPii(task) && (refileHead || approvalHead) && !evidence?.head
+      ? await readSdlcPrHead(receipt, read) : evidence?.head;
+    if (beforeHeadRead !== undefined) {
+      const current = this.need(task.id, false, true);
+      if (identity(current) !== beforeHeadRead) throw new PreEffectToolRefusal(`task #${task.id}: task or review head changed during PR readback; reload and retry`);
+    }
+    if (refileHead) {
+      if (!refileHead.recorded || !currentHead) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded);
+      if (currentHead !== refileHead.recorded) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded, currentHead);
+    } else if (approvalHead && currentHead && currentHead !== approvalHead) throw this.reviewHeadMoveRefusal(task.id, approvalHead, currentHead);
     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);
@@ -5391,7 +5776,7 @@ export class Tasks {
     const metadata = acceptRefs(refs);
     const task = this.need(id, false, true);
     this.mine(task, by, "owner", true);
-    this.acceptanceCapacity(task);
+    this.acceptanceCapacity(task, 0, "check"); // #1080: an urgent task may still take unaccepted offers; `accept` does that, after its gates
     if (metadata && !this.isPii(task) && (!this.nameable(metadata.repo!) || looksSecret(metadata.repo!) || this.aboutPrivatePath("", metadata.repo!, task))) throw new PreEffectToolRefusal("this repository metadata is private or sensitive and is not kept");
     const draft = metadata ? { ...task, refs: { ...task.refs, ...metadata } } : task;
     this.warmRepository(draft);
@@ -5420,7 +5805,52 @@ export class Tasks {
     if (gap) this.releaseNotice(`task ${this.publicTitle(current)}: ${gap}`);
   }
 
-  private acceptanceCapacity(task: Pick<Task, "id" | "owner" | "reserved" | "state"> & Partial<Pick<Task, "history">>, excludePending = 0): void {
+  /**
+   * What counts toward `owner`'s WIP, split for a refusal and for #1080: `offered` is work handed to the owner that it has not accepted
+   * (state proposed), `reserved` is ownerless planner-pulled work held for it, and `accepted` is everything the owner is actually carrying
+   * (in progress, changes requested, in review).
+   */
+  private wipSplit(owner: PeerId, except: number): { accepted: Task[]; offered: Task[]; reserved: Task[] } {
+    const open = this.d.board.list().filter(other => other.id !== except && !["backlog", "approved", "cancelled"].includes(other.state)
+      && (other.owner === owner || !other.owner && other.reserved === owner && this.plannerPullRecord(other)?.pull));
+    return {
+      accepted: open.filter(other => other.owner === owner && other.state !== "proposed"),
+      offered: open.filter(other => other.owner === owner && other.state === "proposed"),
+      reserved: open.filter(other => !other.owner),
+    };
+  }
+  private static isUrgent(task: Pick<Task, "priority" | "signals">): boolean {
+    return (task.priority ?? (task.signals?.includes("urgent") ? 0 : 2)) === 0;
+  }
+  /** #1080: an offer an urgent accept may take back. Never accepted or started work, never another urgent task, never person-pinned work. */
+  private displaceable(offer: Task): boolean {
+    return offer.state === "proposed" && !!offer.owner && !offer.pinned && !Tasks.isUrgent(offer) && !taskHasStarted(offer);
+  }
+  /**
+   * #1080: the owner is at its limit only because of offers it never accepted, so an urgent task takes the slot. The newest offers go back to
+   * routing (ownerless, in To Do) and the planners are told. Called only from `accept`, immediately before its write.
+   */
+  private displaceOffers(urgent: Task, owner: PeerId, offers: readonly Task[]): void {
+    for (const offer of offers) {
+      // A planner-pulled offer also holds a counted reservation (`plannerWip` counts an ownerless proposed task reserved for the owner with pull history), so clearing the owner alone frees no slot. `decline` clears it the same way.
+      const pulled = this.plannerPullRecord(offer)?.pull === true;
+      const next = this.d.board.update(offer.id, HUB, "unassigned", { owner: null, reviewer: null, ...(pulled ? { reserved: null } : {}) }, `displaced by urgent task #${urgent.id}: ${owner} was at its WIP limit with this offer unaccepted`, {}, offer.history.length);
+      this.offered.delete(offer.id);
+      this.releaseNotice(`task #${offer.id}: displacement cohort cleanup unavailable`, () => this.cohorts.leave(offer.id));
+      this.withdrawRoleRequest(offer, next, "owner");
+      this.withdrawRoleRequest(offer, next, "reviewer");
+      this.releaseNotice(`task #${offer.id}: displacement notice unavailable`, () => {
+        const body = `Task #${offer.id} was taken back from ${owner}: urgent task #${urgent.id} (priority 0 or marked urgent) needed ${owner}'s WIP slot and #${offer.id} was only offered, never accepted. It is ownerless in To Do and routes again; plan it again if it should wait for ${owner}.`;
+        this.d.notify(body);
+        for (const planner of this.taskPlanner(offer)) this.d.bus.publish(newEnvelope(HUB, sanitize(body), { to: [planner], kind: "task", refs: { task: String(offer.id) }, ...(this.isPii(offer) ? { private: true } : {}) }));
+      });
+    }
+  }
+  /**
+   * `urgent`: "refuse" (default) never displaces; "check" only tells whether an urgent accept could (a pre-check before a later write); "displace"
+   * performs it. Only `accept` displaces.
+   */
+  private acceptanceCapacity(task: Pick<Task, "id" | "owner" | "reserved" | "state"> & Partial<Pick<Task, "history" | "priority" | "signals">>, excludePending = 0, urgent: "refuse" | "check" | "displace" = "refuse"): void {
     const owner = task.owner ?? task.reserved;
     if (!owner) return;
     if ((task.state === "in_progress" || task.state === "changes_requested") && task.history) {
@@ -5434,10 +5864,30 @@ export class Tasks {
       if (task.history.slice(boundary).some(entry => entry.event === "accepted" && (entry.by === owner || entry.by === USER))) return;
     }
     const limit = this.wipLimit(owner), pending = Math.max(0, (this.pendingClaims.get(owner) ?? 0) - excludePending);
-    if (this.wip(owner, task.id) + pending < limit) return;
-    const open = this.d.board.list().filter(other => other.id !== task.id && !["backlog", "approved", "cancelled"].includes(other.state)
-      && (other.owner === owner || !other.owner && other.reserved === owner && this.plannerPullRecord(other)?.pull)).map(other => `#${other.id}`);
-    throw new PreEffectToolRefusal(`planner WIP capacity for ${owner}: limit ${limit}; open tasks ${open.join(", ") || "none"}${pending ? `; pending claims ${pending}` : ""}`);
+    const used = this.wip(owner, task.id) + pending;
+    if (used < limit) return;
+    const split = this.wipSplit(owner, task.id), ids = (rows: readonly Task[]) => rows.map(row => `#${row.id}`).join(", ") || "none";
+    // #1080: an urgent task that is the owner's own offer may take back only as many never-accepted offers as it needs, newest first. Anything else refuses.
+    if (urgent !== "refuse" && task.state === "proposed" && task.owner === owner && Tasks.isUrgent(task as Pick<Task, "priority" | "signals">)) {
+      const need = used + 1 - limit;
+      const takeable = split.offered.filter(offer => this.displaceable(offer))
+        .sort((a, b) => handedAt(b) - handedAt(a) || b.id - a.id);
+      if (need > 0 && takeable.length >= need) {
+        if (urgent === "displace") {
+          this.displaceOffers(task as Task, owner, takeable.slice(0, need));
+          // Defense in depth (#1080): no displacement path may leave the owner over its limit. Clearing the reservation above makes this unreachable today; if it ever fires, the offers are already back in To Do and only the accept is refused.
+          const after = this.wip(owner, task.id) + pending;
+          if (after >= limit) throw new Error(`planner WIP capacity for ${owner}: limit ${limit}; the offers taken back for urgent task #${task.id} are back in To Do but did not free a slot (WIP is now ${after}), so it stays offered; ask the planner to check ${owner}'s reservations, then accept it again`);
+        }
+        return;
+      }
+    }
+    const open = [...split.accepted, ...split.offered, ...split.reserved].sort((a, b) => a.id - b.id);
+    const parts = [`accepted ${ids(split.accepted)}`, `offered, not yet accepted ${ids(split.offered)}`, ...(split.reserved.length ? [`reserved, not yet offered ${ids(split.reserved)}`] : [])];
+    const next = split.accepted.length >= limit
+      ? `finish or hand back an accepted task first`
+      : `decline an offered task you will not take, or finish an accepted one; an urgent task may take back an offer you have not accepted`;
+    throw new PreEffectToolRefusal(`planner WIP capacity for ${owner}: limit ${limit}; open tasks ${ids(open)} (${parts.join("; ")})${pending ? `; pending claims ${pending}` : ""}; ${next}`);
   }
 
   /**
@@ -5452,7 +5902,8 @@ export class Tasks {
     this.ready(task, true);
     if (task.state !== "proposed" && task.state !== "changes_requested" && task.state !== "in_progress") throw new PreEffectToolRefusal(`task #${task.id} is ${task.state}: cannot move to in_progress`);
     this.studyDispatchCheck(task, task.owner ?? undefined);
-    this.acceptanceCapacity(task);
+    this.declaredNeedCheck(task, task.owner ?? by); // the owner's capability, also when the console user accepts on its behalf (`mine` admits USER)
+    this.acceptanceCapacity(task, 0, "check");
     // S1 spec acceptance and S9 plan review are independent prerequisites; retain S1's missing-spec refusal first.
     if (this.specGated(task) && this.d.sdlc?.config().mode === "enforce" && specState(task.sdlc, undefined) === "missing") throw new PreEffectToolRefusal(this.specText(task, "missing", "blocked"));
     if ((this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode === "enforce" && this.isBuildTask(task)) {
@@ -5480,7 +5931,13 @@ export class Tasks {
     const repositoryChanged = this.repositories.scope(task.refs).key !== this.repositories.scope(draft.refs).key;
     const before = new Set(this.overlapHits(task).map((h) => h.task.id));
     this.studyDispatchCheck(task, task.owner ?? undefined);
-    const next = this.linkOnWrite(this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) })); // #723: refs.repo may have just arrived
+    // #1115: a hub-sandboxed peer cannot run `git worktree add`, so for work that declares a worktree the hub makes it here, before any write. Anything that throws below clears it again.
+    const undoWorktree = this.hubWorktreeFor(task, task.owner ?? by);
+    let next: Task;
+    try {
+      this.acceptanceCapacity(task, 0, "displace"); // #1080: every gate has passed; synchronous from here to the accept write
+      next = this.linkOnWrite(this.d.board.update(task.id, by, "accepted", { state: "in_progress", ...(cleaned ? { plan: cleaned } : {}), ...(metadata ? { refs: metadata } : {}) })); // #723: refs.repo may have just arrived
+    } catch (error) { undoWorktree?.(); throw error; }
     this.captureOwnerAcceptance(next);
     this.d.notify(`task ${this.publicTitle(next)} accepted by ${by}`);
     if (repositoryChanged) this.cohorts.leave(next.id);
@@ -5541,6 +5998,51 @@ export class Tasks {
   /** #572 AC3: what the owner's `hub_task_done` result adds while the project root checkout is on a task branch. */
   checkoutNote = (): string | undefined => { const warning = mainCheckoutWarning(this.d.cwd, this.publicMetadataText); return warning ? `Note: ${warning}.` : undefined; };
 
+  /**
+   * #1115, #1129: the hub makes the worktree of a hub-sandboxed owner for write-class work (`implement`, `bulk_edit`) and for any work that declares `needs_worktree`. Returns a function that clears it again, or
+   * undefined when there is nothing to clear (another peer, a read-only class that did not declare it, a PII task, or a worktree an earlier accept already made). A failure refuses the
+   * accept before any board write and names the cause and the next step; nothing is left behind.
+   */
+  private hubWorktreeFor(task: Task, peer: PeerId): (() => void) | undefined {
+    const port = this.d.taskWorktree;
+    if (!port || peer === USER || peer === HUB || !port.applies(peer) || this.isPii(task) || !(task.signals.includes("needs_worktree") || writesRepository(task.class))) return undefined;
+    const made = port.create({ peer, task: task.id });
+    if (!made.ok) throw new PreEffectToolRefusal(`task #${task.id} needs its own git worktree and the hub could not make one for ${peer}: ${made.reason}; nothing was created, so no branch ref is left behind. Decline the task so the hub offers it to a peer that makes its own worktree`);
+    return made.created ? () => { try { port.remove({ peer, task: task.id }); } catch { /* the accept error that got us here is the one reported */ } } : undefined;
+  }
+
+  /** The hub-made worktree of the task's owner, for the accept answer: where to edit, and what the hub does at `hub_task_done`. */
+  worktreeNote(task: Task, peer: PeerId): string | undefined {
+    const found = this.d.taskWorktree?.describe(peer, task.id);
+    return found ? `Worktree: the hub made ${found.path} on branch ${found.branch} for this task. Edit files there only; do not run git. At hub_task_done the hub stages, commits and pushes it for you.` : undefined;
+  }
+
+  /**
+   * #1115: at `hub_task_done` the hub commits and pushes a hub-sandboxed peer's worktree and answers the refs the done carries. Undefined when the peer made no
+   * hub worktree for this task (it commits itself). A refused commit or push is a pre-effect refusal that names the cause and the next step: the board is untouched.
+   */
+  async worktreeHandoff(by: PeerId, id: unknown, refs: unknown): Promise<TaskRefs | undefined> {
+    const port = this.d.taskWorktree;
+    if (!port || by === USER || by === HUB || !port.applies(by)) return undefined;
+    const task = this.need(id, false, true);
+    this.mine(task, by, "owner", true);
+    if (this.isPii(task) || !port.describe(by, task.id)) return undefined;
+    const result = await port.commitAndPush({ peer: by, task: task.id, title: task.title });
+    if (!result.ok) throw new PreEffectToolRefusal(`hub_task_done for task #${task.id}: ${result.reason}`);
+    if (result.note) this.doneNotes.set(task.id, result.note);
+    return { ...cleanRefs(refs), commit: result.commit, branch: result.branch };
+  }
+
+  /** Decline or cancel: clear the hub-made worktree and its empty branch. Uncommitted work is kept and reported, never force-removed. */
+  private releaseHubWorktree(task: Task, peer: PeerId | null | undefined): void {
+    const port = this.d.taskWorktree;
+    if (!port || !peer || peer === USER || peer === HUB || !port.applies(peer)) return;
+    this.releaseNotice(`task #${task.id}: the hub-made worktree could not be cleared`, () => {
+      const removal = port.remove({ peer, task: task.id });
+      if (removal.kept) this.d.notify(`task #${task.id}: ${removal.kept}`);
+    });
+  }
+
   /**
    * `capacity` (#531): the owner has no room right now, so the decline excludes it only from this move's own reroute
    * (below), never from a later reroute or planner pull. Without it, a decline is a lasting refusal (`excluded()`), and so
@@ -5555,6 +6057,7 @@ export class Tasks {
     const back = this.d.board.update(task.id, by, "declined", { ...(["in_progress", "changes_requested"].includes(task.state) ? { state: "proposed" as const } : {}), ...(planned ? { reserved: null } : {}) }, reason, task.owner ? { from: task.owner, ...(capacity === true ? { capacity: true as const } : {}) } : {});
     if (planned) this.offered.delete(task.id);
     this.d.notify(`task ${this.publicTitle(back)} declined${capacity === true ? " (capacity only)" : ""} by ${by}${reason && !this.isPii(back) ? `: ${reason}` : ""}`);
+    this.releaseHubWorktree(task, task.owner ?? by);
     // A capacity decline is not in excluded(), so this move's own reroute leaves the decliner out explicitly.
     try {
       return await this.assignOwner(back, HUB, { event: "reassigned", reason: "declined", clearOnFail: true, ...(capacity === true && task.owner ? { exclude: [task.owner] } : {}), ...(planned ? { planner: true } : {}) });
@@ -5731,18 +6234,27 @@ export class Tasks {
     if (state !== "OPEN" && state !== "CLOSED") throw new PreEffectToolRefusal(`task #${task.id}: PR merge state unavailable; cannot reopen approval`);
   }
 
-  async done(by: PeerId, id: unknown, summary?: string, refs?: TaskRefs, deliverables?: unknown): Promise<Task> {
+  async done(by: PeerId, id: unknown, summary?: string, refs?: TaskRefs, deliverables?: unknown, specAck?: unknown): Promise<Task> {
     const requestCheck = this.requestCheck(by);
     const initial = this.need(id, false, true);
     this.mine(initial, by, "owner", true);
     let refresh: CompletionRefresh | undefined;
     if (initial.state === "in_review" || initial.state === "approved") {
       const commit = cleanRefs(refs).commit;
-      if (!commit || !/^[a-f0-9]{40}$/.test(commit) || commit === this.reviewHead(initial))
-        throw new PreEffectToolRefusal(`task #${initial.id} is already ${initial.state}; re-file requires a different full head SHA`);
+      const recorded = this.ownerReviewHead(initial) ?? this.findingHead(initial);
+      const currentReviewHead = this.ownerReviewHead(initial) ?? this.reviewHead(initial);
+      if (!commit || !/^[a-f0-9]{40}$/.test(commit) || commit === currentReviewHead) {
+        throw new PreEffectToolRefusal(`task #${initial.id} is already ${initial.state}${recorded ? ` with recorded review head ${recorded}` : ""}; re-file requires a different full head SHA. Owner must re-file hub_task_done with refs.commit set to the new full SHA`);
+      }
       refresh = { revision: initial.history.length, commit, state: initial.state };
     }
     const submittedCommit = cleanRefs(refs).commit;
+    if (submittedCommit && this.hasReviewHistory(initial) && !/^[a-f0-9]{40}$/.test(submittedCommit)) {
+      const recorded = this.ownerReviewHead(initial);
+      throw new PreEffectToolRefusal(`task #${initial.id}: re-file after review needs refs.commit to be a full lowercase SHA${recorded ? ` (recorded review head ${recorded})` : ""}; owner must re-file hub_task_done with the new full SHA in refs.commit`);
+    }
+    const refileHead: RefileHeadGuard | undefined = !submittedCommit && initial.sdlc?.repo && initial.sdlc.pr && this.hasReviewHistory(initial) && !this.isPii(initial)
+      ? { recorded: this.ownerReviewHead(initial) } : undefined;
     const draft = refresh ?? (submittedCommit && /^[a-f0-9]{40}$/.test(submittedCommit) ? { commit: submittedCommit } : undefined);
     const valid = () => { requestCheck(); return this.completionDraft(this.completionCurrent(id, by, true, refresh), draft); };
     if (initial.state === "approved") { await this.unmergedForReopen(initial, valid); valid(); }
@@ -5766,9 +6278,19 @@ export class Tasks {
     const current = () => this.withLink(valid(), link, refs);
     task = current();
     let reviewEvidence: PrEvidence | undefined;
-    if (this.d.sdlc && this.d.sdlc.config().mode !== "off") { reviewEvidence = await this.lifecycleGate(task, "review"); task = current(); }
-    const reviewAdmission = task.reviewer || this.d.prepareReviewBrief ? await this.reviewRequestAdmission(task, refs, true, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, draft), link, refs), !task.reviewer) : undefined;
+    if (this.d.sdlc && this.d.sdlc.config().mode !== "off") { reviewEvidence = await this.lifecycleGate(task, "review", undefined, undefined, refileHead); task = current(); }
+    const reviewAdmission = task.reviewer || this.d.prepareReviewBrief ? await this.reviewRequestAdmission(task, refs, true, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, draft), link, refs), !task.reviewer, refileHead) : undefined;
     task = current();
+    if (refileHead && (this.d.sdlc?.config().mode ?? "off") === "off") {
+      const currentHead = await this.currentPrHeadForReview(task, current);
+      task = current();
+      if (!refileHead.recorded || !currentHead) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded);
+      if (currentHead !== refileHead.recorded) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded, currentHead);
+    }
+    const currentSpecTask = () => { const fresh = current(); return { ...fresh, refs: { ...fresh.refs, ...cleanRefs(refs) } }; };
+    const specInspection = await this.inspectTaskSpecs(currentSpecTask(), by, specAck, currentSpecTask);
+    task = current(); // the host head and task authority are revalidated after spec inspection
+    this.assertSpecInspection(specInspection, { ...task, refs: { ...task.refs, ...cleanRefs(refs) } }, by);
     // A member of a silent cohort (issue #107): its done is an intent, and the last of them integrates first.
     const cohort = this.cohorts.of(task.id);
     const silentMember = !!cohort?.silent && this.turnFree() && !!task.owner && !this.isPii(task);
@@ -5799,19 +6321,23 @@ export class Tasks {
     }
     if (task.state === "proposed" || task.state === "changes_requested") task = this.withLink(this.d.board.update(task.id, by, "accepted", { state: "in_progress" }, WITH_DONE), link, refs); // done without a separate accept
     const command = this.d.runCheck ? this.d.check?.(task.class, task) : undefined;
-    if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission, link, records, requestCheck, refresh);
+    if (!command) return this.complete(task, by, summary, refs, "", withheld, "review", reviewAdmission, link, records, requestCheck, refresh, specInspection);
     // The tool call returns now; a check can outlast an agent's tool timeout. The result decides what comes next.
     if (refresh?.state === "approved") { await this.unmergedForReopen(task, valid); task = current(); }
     this.checking.set(task.id, task.owner);
     const checkedRefs = cleanRefs(refs);
+    if (specInspection.report?.head && !checkedRefs.commit) checkedRefs.commit = specInspection.report.head;
+    if (specInspection.report && specInspection.repo && !checkedRefs.repo) checkedRefs.repo = specInspection.repo;
+    const storedRefs = { ...task.refs, ...checkedRefs };
     this.warmRepository({ ...task, refs: { ...task.refs, ...checkedRefs } });
-    const pending = this.d.board.update(task.id, by, "done (checking)", { ...(refresh ? { state: "in_progress" as const } : {}), ...(refresh?.state === "approved" && !task.reviewer ? { reviewer: USER } : {}), codeSymbols: this.observedCodeSymbols({ ...task, refs: { ...task.refs, ...checkedRefs } }), refs: checkedRefs, ...(task.sdlc ? { sdlc: task.sdlc } : {}) }, summary, { withheld: withheld || undefined, ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    this.assertSpecInspection(specInspection, { ...task, refs: storedRefs }, by);
+    const pending = this.d.board.update(task.id, by, "done (checking)", { ...(refresh ? { state: "in_progress" as const } : {}), ...(refresh?.state === "approved" && !task.reviewer ? { reviewer: USER } : {}), codeSymbols: this.observedCodeSymbols({ ...task, refs: storedRefs }), refs: checkedRefs, ...(task.sdlc ? { sdlc: task.sdlc } : {}) }, summary, { withheld: withheld || undefined, ...(records ? { deliverables: records } : {}), ...(specInspection.report ? { specReport: specInspection.report, specRefBinding: this.specRefBinding({ refs: storedRefs }) } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
     if (refresh) { this.ciWatchers.cancel(pending.id); this.heldReviews.delete(pending.id); }
     this.releaseNotice(`task ${this.publicTitle(pending)} done by ${by}; its check is queued or running: ${command}`);
     const seen = { events: pending.history.length, owner: pending.owner };
     this.pendingChecks++;
     this.checkQueue = this.checkQueue
-      .then(() => this.finishChecked(pending.id, by, summary, command, seen, withheld))
+      .then(() => this.finishChecked(pending.id, by, summary, command, seen, withheld, specInspection))
       .catch((e: Error) => {
         this.releaseNotice(`task #${pending.id}: its check result could not be recorded: ${e.message}`);
         this.releaseNotice(`task #${pending.id}: its owner retry notice could not be published`, () => {
@@ -5914,7 +6440,7 @@ export class Tasks {
     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> {
+  private async finishChecked(id: number, by: PeerId, summary: string | undefined, command: string, seen: { events: number; owner: PeerId | null }, withheld: boolean, specInspection: PreparedSpecInspection): 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);
     const task = this.d.board.get(id);
@@ -5930,6 +6456,7 @@ export class Tasks {
       return;
     }
     if (result.code === 0 && !result.timedOut) {
+      const refileForSpecs = this.refreshAsyncSpecInspection(specInspection, task, by);
       // An integrating member's check counts only for the target it confirmed (issue #107).
       const cohort = this.cohorts.of(id);
       if (cohort?.silent && !this.cohorts.holds(id, ownerGen(task), this.tree(cohort))) {
@@ -5938,8 +6465,9 @@ export class Tasks {
         return;
       }
       this.d.board.update(id, HUB, "check passed", {}, `${outcome}\n${result.tail}`.trim(), this.checkProvenance(task, result.tail));
+      if (refileForSpecs) { this.requestSpecRefile(task); return; }
       // 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);
+      await this.complete(this.d.board.get(id)!, by, `${summary ?? ""}\nCheck: ${outcome}`.trim(), undefined, result.tail, withheld, undefined, undefined, undefined, undefined, undefined, undefined, specInspection, true);
       return;
     }
     this.d.board.update(id, HUB, "check failed", {}, `${outcome}\n${result.tail}`.trim(), this.checkProvenance(task, result.tail));
@@ -5951,8 +6479,9 @@ export class Tasks {
   }
 
   /** `gated`: the transition `done()` already gated with no await since, so it is not read back twice (#382). */
-  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review", admission?: ReviewReadiness, link?: IdentityLink, records?: DeliverableRecord[], requestCheck: () => void = () => {}, refresh?: CompletionRefresh): Promise<Task> {
+  private async complete(task: Task, by: PeerId, summary?: string, refs?: TaskRefs, checkOutput = "", withheld = false, gated?: "review", admission?: ReviewReadiness, link?: IdentityLink, records?: DeliverableRecord[], requestCheck: () => void = () => {}, refresh?: CompletionRefresh, specInspection?: PreparedSpecInspection, asyncCheckCompletion = false): Promise<Task> {
     requestCheck();
+    if (specInspection && asyncCheckCompletion && this.refreshAsyncSpecInspection(specInspection, task, by)) { this.requestSpecRefile(task); return task; }
     // A check's completion carries the records its `done (checking)` bound: the same bytes the owner delivered, not a later read.
     records ??= latestPendingDeliverables(task);
     const submittedCommit = cleanRefs(refs).commit;
@@ -5964,6 +6493,7 @@ export class Tasks {
       reviewEvidence = await this.lifecycleGate(task, reviewer ? "review" : "approval");
       requestCheck();
       task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, false, refresh), draft), link, refs);
+      if (specInspection && asyncCheckCompletion && this.refreshAsyncSpecInspection(specInspection, task, by)) { this.requestSpecRefile(task); return task; }
       selection = this.poolReview(task, refs);
       reviewer = selection?.reviewer ?? task.reviewer ?? (refresh?.state === "approved" ? USER : undefined);
     }
@@ -5972,6 +6502,7 @@ export class Tasks {
       admission = await this.reviewRequestAdmission(task, refs, false, by, reviewEvidence, undefined, staged => this.withLink(this.completionDraft(staged, draft), link, refs), !reviewer);
       requestCheck();
       task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, false, refresh), draft), link, refs);
+      if (specInspection && asyncCheckCompletion && this.refreshAsyncSpecInspection(specInspection, task, by)) { this.requestSpecRefile(task); return task; }
     }
     selection = this.poolReview(task, refs);
     reviewer = selection?.reviewer ?? task.reviewer ?? (refresh?.state === "approved" ? USER : undefined);
@@ -5981,12 +6512,21 @@ export class Tasks {
     if (refresh?.state === "approved") {
       await this.unmergedForReopen(task, () => { requestCheck(); return this.completionCurrent(task.id, by, true, refresh); });
       task = this.withLink(this.completionDraft(this.completionCurrent(task.id, by, true, refresh), draft), link, refs);
+      if (specInspection && asyncCheckCompletion && this.refreshAsyncSpecInspection(specInspection, task, by)) { this.requestSpecRefile(task); return task; }
     }
     const completedRefs = cleanRefs(refs);
-    this.warmRepository({ ...task, refs: { ...task.refs, ...completedRefs } });
-    const noWrites = this.noWritesRecorded({ ...task, refs: { ...task.refs, ...completedRefs } });
+    if (specInspection?.report?.head && !completedRefs.commit) completedRefs.commit = specInspection.report.head;
+    if (specInspection?.report && specInspection.repo && !completedRefs.repo) completedRefs.repo = specInspection.repo;
+    const storedRefs = { ...task.refs, ...completedRefs };
+    if (specInspection) {
+      if (asyncCheckCompletion) {
+        if (this.refreshAsyncSpecInspection(specInspection, { ...task, refs: storedRefs }, by)) { this.requestSpecRefile(task); return task; }
+      } else this.assertSpecInspection(specInspection, { ...task, refs: storedRefs }, by);
+    }
+    this.warmRepository({ ...task, refs: storedRefs });
+    const noWrites = this.noWritesRecorded({ ...task, refs: storedRefs });
     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 || refresh?.state === "approved" ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection, { ...task, refs: { ...task.refs, ...completedRefs } }), ...(reviewCost ? { reviewCost } : {}), ...(records ? { deliverables: records } : {}) }, task.history.length, HOST_CODE_SYMBOLS);
+    const next = this.d.board.update(task.id, by, "done", { codeSymbols: this.observedCodeSymbols({ ...task, refs: storedRefs }), state: reviewer ? "in_review" : "approved", ...(selection || refresh?.state === "approved" ? { reviewer: reviewer ?? USER } : {}), ...(task.sdlc ? { sdlc: { ...task.sdlc, stage: lifecycleStage(this.d.sdlc?.config() ?? sdlcConfig(undefined), reviewer ? "review" : "merge") } } : {}), refs: completedRefs }, checkOutput ? `${routedSummary ?? ""}\n${checkOutput}`.trim() : routedSummary, { ...this.planObservation(task), withheld: withheld || undefined, ...(specInspection?.report ? { specReport: specInspection.report, specRefBinding: this.specRefBinding({ refs: storedRefs }) } : {}), ...(noWrites ? { noWrites: true as const } : {}), ...this.reviewMetadata(selection, { ...task, refs: storedRefs }), ...(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)
@@ -6101,7 +6641,7 @@ export class Tasks {
 
   /** The one place a review request is written: the first reviewer and a replacement get the same text, refs and privacy. */
   /** Review admission is separate from brief construction (#228). All refusals precede the requesting done's writes. */
-  private async reviewRequestAdmission(task: Task, refs?: TaskRefs, preEffect = true, actor: PeerId = task.owner ?? USER, previous?: PrEvidence, sameRequest?: () => boolean, stage: (task: Task) => Task = task => task, prepareOnly = false): Promise<ReviewReadiness | undefined> {
+  private async reviewRequestAdmission(task: Task, refs?: TaskRefs, preEffect = true, actor: PeerId = task.owner ?? USER, previous?: PrEvidence, sameRequest?: () => boolean, stage: (task: Task) => Task = task => task, prepareOnly = false, refileHead?: RefileHeadGuard): Promise<ReviewReadiness | undefined> {
     const mode = (this.d.sdlc?.config() ?? sdlcConfig(undefined)).mode;
     if (mode === "off" && !this.d.prepareReviewBrief) return undefined;
     let quietDrift = false;
@@ -6138,8 +6678,13 @@ export class Tasks {
     const evidence: ReviewReadiness = this.isPii(task)
       ? { ready: false, blockers: ["private review readiness unavailable"] }
       : task.sdlc ? reviewReadinessFromEvidence(previous, expected, this.d.sdlc?.config().requiredChecks ?? []) ?? await readReviewReadiness(task.sdlc, expected, read, this.d.sdlc?.config().requiredChecks ?? []) : { ready: false, blockers: ["review PR identity missing"] };
+    const currentHead = refileHead && !evidence.head && task.sdlc ? await readSdlcPrHead(task.sdlc, read) : evidence.head;
     const current = guard();
     const admitted: ReviewReadiness = quietDrift ? { ready: false, blockers: ["review readiness unknown: task changed during readback"] } : evidence;
+    if (refileHead) {
+      if (!refileHead.recorded || !currentHead) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded);
+      if (currentHead !== refileHead.recorded) throw this.reviewHeadMoveRefusal(task.id, refileHead.recorded, currentHead);
+    }
     if (!admitted.ready) {
       const message = `task ${this.publicTitle(current)}: premature review: ${admitted.blockers.join("; ")}`;
       if (mode === "enforce") throw new (preEffect ? PreEffectToolRefusal : Error)(message);
@@ -6417,17 +6962,19 @@ export class Tasks {
   briefText(task: Task): string {
     if (this.isPii(task)) return "";
     const approval = approvalText(approvalBinding(task));
-    const prefix = (brief: string) => [approval, brief].filter(Boolean).join("\n");
-    if (!task.refs.commit) return approval;
+    const spec = this.currentSpecReport(task);
+    const prefix = (brief: string) => [approval, spec ? renderSpecTaskReport(spec) : "", brief].filter(Boolean).join("\n");
+    if (!task.refs.commit) return prefix("");
     try {
       const brief = this.d.reviewBrief?.(task);
-      if (!brief) return approval;
+      if (!brief) return prefix("");
       return prefix("unavailable" in brief ? `Review brief unavailable: ${brief.unavailable}.` : sanitize(renderReviewBrief(brief)));
     } catch { return prefix("Review brief unavailable: it could not be built."); }
   }
 
   async review(by: PeerId, id: unknown, verdict: unknown, note?: string, unmet?: unknown, head?: unknown, coverage?: unknown, findings?: unknown): Promise<Task> {
     const requestCheck = this.requestCheck(by);
+    if (typeof id !== "number" && !(typeof id === "string" && /^\s*\d+\s*$/.test(id))) this.need(id, false, true);
     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
@@ -6471,7 +7018,7 @@ export class Tasks {
     // notice. The rule is structural (a finding with disposition open), never a reading of the unmet text.
     const codeScope = by !== USER && this.d.reviewScope?.(by) === "code";
     const evidenceOnly = codeScope && verdict === "changes_requested" && !parsed.some(finding => finding.disposition === "open");
-    const resolvedHead = this.findingHead(initial);
+    const resolvedHead = this.ownerReviewHead(initial) ?? this.findingHead(initial);
     let findingHead = resolvedHead;
     if (head !== undefined) {
       try { findingHead = sdlcReceipt({ reviewedHead: head }, initial.sdlc, this.d.sdlc?.config() ?? sdlcConfig(undefined)).reviewedHead; }
@@ -6518,7 +7065,7 @@ export class Tasks {
         if (gap.length) note = `${note ?? ""}\nCoverage gap (${gap.length}): ${list(gap)}`.trim();
       }
     }
-    if (head !== undefined && resolvedHead && findingHead !== resolvedHead) throw new PreEffectToolRefusal("supplied review head differs from the task resolved head");
+    if (head !== undefined && resolvedHead && findingHead !== resolvedHead) throw new PreEffectToolRefusal(`task #${initial.id}: supplied review head ${findingHead} differs from recorded task head ${resolvedHead}; owner must re-file hub_task_done with refs.commit set to the supplied full SHA before review`);
     // The PII screen reads the note of a review that passes these checks (issue #198); they run again after it.
     const withheld = await this.withholds("review note", parsed.length ? JSON.stringify({ note, findings: parsed }) : note, valid())
       || parsed.length > 0 && !this.findingTextAllowed(initial, parsed);
@@ -6555,6 +7102,12 @@ export class Tasks {
       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();
+    } else if (verdict === "approved" && this.d.sdlc?.config().mode === "off" && this.d.sdlc?.gh && task.sdlc?.repo && task.sdlc.pr
+      && this.ownerReviewHead(task) && !this.isPii(task)) {
+      const expected = reviewedHead ?? this.ownerReviewHead(task) ?? this.findingHead(task);
+      const currentHead = await this.currentPrHeadForReview(task, valid);
+      task = valid();
+      if (expected && currentHead && currentHead !== expected) throw this.reviewHeadMoveRefusal(task.id, expected, currentHead);
     }
     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)) {