@fradser/pi-agent-teams 0.8.2 → 0.9.0

package/src/team-machine.ts

@@ -10,17 +10,23 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { modelLabel, runPiWorker } from "@fradser/pi-kit";
+
+/** pi thinking levels, mirrored from @earendil-works/pi-agent-core. */
+type LeaderThinkingLevel = NonNullable<ExtensionContext["thinkingLevel"]>;
+const THINKING_LEVELS: readonly LeaderThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+import { modelLabel, runPiWorker, type RunPiWorkerOptions } from "@fradser/pi-kit";
 import { MODEL_INHERIT_ALIAS, discoverAgents, persistAgentDefinition, registerSessionAgent, resolveAgent, type AgentDefinition, type AgentDefinitionInput } from "./agents.ts";
 import {
   activeAssignmentConflict,
   applyClaimIntent,
   assignTeammate,
+  boardRevision,
   claimableTasks,
-  clearStateDirty,
   clearWorkerRunEvents,
   completeTask,
   createTask,
+  createDirectWork,
+  discardDirectWork,
   deliverToLeader,
   getPeerInboxOffset,
   getState,
@@ -29,18 +35,25 @@ import {
   idleTeammates,
   isPeerDelivered,
   isValidTeammateName,
-  listTasks,
+  listTeammates,
   livingTeammates,
   loadBoard,
+  markBoardChanged,
   markPeerDelivered,
-  markStateDirty,
+  getTask,
   normalizeResources,
+  progressRevision,
   registerTeammate,
   releaseTask,
   releaseTasksOf,
+  reclaimDirectWork,
+  taskDependenciesMet,
   receiveWorkerMessage,
+  reopenCompletedWork,
   setPeerInboxOffset,
+  rosterRevision,
   setPeerDeliveryState,
+  stateRevision,
   updateTeammate,
   updateTeammateProgress,
 } from "./state.ts";
@@ -65,22 +78,26 @@ import {
 } from "./statefile.ts";
 import { isWorkerEvent } from "./types.ts";
 import {
+  deliverFreshAssignment,
   deliverPrompt,
   isCleanExit,
+  isFreshAssignmentPending,
   resolveWorkerTools,
   sendWorkerSteer,
+  sendWorkerFollowUp,
   spawnResident,
   terminateAllTeammates,
   terminateTeammate,
   unknownWorkerTools,
   WORKER_TOOL_UNIVERSE,
   type WorkerProcessResult,
+  type ResidentSpawnOptions,
 } from "./spawner.ts";
 import { captureWorktreeDiff, cleanupWorktree, createWorktree, discardWorktree } from "./worktree.ts";
 import { messageTitle, type InboxMessage, type Teammate, type WorkerAssignment, type WorkerUsage } from "./types.ts";
-import type { FollowUpReport } from "./follow-up-queue.ts";
+import { exactSessionRoute, resolveExactSession } from "./recipient.ts";
+import type { LeaderReport } from "./leader-reports.ts";
 
-export const MAX_SESSION_WORKERS = 8;
 /** Harness coordination cadence: outbox drain every tick, notices paced. */
 const LIVE_POLL_MS = 500;
 /** Minimum gap between claimable-task notices per teammate. One-shot noticing
@@ -96,17 +113,10 @@ export const VERIFY_FAILURE_ESCALATE_AFTER = 2;
 const MAX_NOTICED_TASK_IDS = 256;
 /** Claimable tasks listed in one wake-prompt board notice. */
 const WAKE_NOTICE_TASK_LIMIT = 10;
-/** Silence is not a work deadline: active stream output keeps a teammate alive.
- * The watchdog may only notify; termination decisions belong to the leader model. */
-const DEFAULT_STALL_NOTICE_MS = 30 * 60 * 1000;
-export const STALL_NOTICE_MS = readDurationEnv("PI_TEAMMATE_STALL_NOTICE_MS", DEFAULT_STALL_NOTICE_MS);
-/** Silence with zero lifetime model output and no tool running is the provider-
- * hang signature: an in-flight request stuck on the model backend will not
- * recover by waiting or steering, so flag it well before the general window so
- * the leader can respawn early. Defaults to five minutes, independent of the
- * notice-pace floor; 0 disables the tier. */
-const DEFAULT_SILENT_STALL_MS = 5 * 60 * 1000;
-export const SILENT_STALL_MS = readDurationEnv("PI_TEAMMATE_SILENT_STALL_MS", DEFAULT_SILENT_STALL_MS);
+/** Console-only silence marker: after this long without output the roster
+ * shows "stalled". It never notifies the leader or terminates anything. */
+const DEFAULT_STALL_SILENCE_MS = 5 * 60 * 1000;
+const STALL_SILENCE_MS = readDurationEnv("PI_TEAMMATE_STALL_SILENCE_MS", DEFAULT_STALL_SILENCE_MS);
 /** Fully-consumed inboxes larger than this are truncated. */
 const INBOX_COMPACT_BYTES = 256 * 1024;
 
@@ -122,15 +132,6 @@ export function stallSilenceMs(teammate: Pick<Teammate, "lastOutputAt">, now = D
   return Math.max(0, now - teammate.lastOutputAt);
 }
 
-export function isStallThresholdReached(
-  teammate: Pick<Teammate, "lastOutputAt">,
-  now: number,
-  thresholdMs: number,
-): boolean {
-  const silence = stallSilenceMs(teammate, now);
-  return thresholdMs > 0 && silence !== undefined && silence >= thresholdMs;
-}
-
 export function formatSilenceDuration(milliseconds: number): string {
   const totalMinutes = Math.floor(Math.max(0, milliseconds) / 60_000);
   if (totalMinutes < 1) return "less than 1m";
@@ -140,42 +141,9 @@ export function formatSilenceDuration(milliseconds: number): string {
   return `${minutes}m`;
 }
 
-/** True when the stream has delivered recognized model activity (text,
- * thinking, tool-call, or tool execution events) at least once — the stall
- * classifier. Usage totals stay diagnostics only: providers may omit them
- * after real output, and an empty message_end artifact must not count. */
-export function hasModelOutput(teammate: Pick<Teammate, "modelOutputSeen">): boolean {
-  return teammate.modelOutputSeen === true;
-}
-
-/** Silence threshold for one teammate. A worker that has never received model
- * output and runs no tool is almost certainly blocked on the provider rather
- * than doing slow work; that signature uses the shorter silent-stall window. */
-export function stallThresholdMs(teammate: Pick<Teammate, "modelOutputSeen" | "activeTool">): number {
-  if (STALL_NOTICE_MS <= 0 || SILENT_STALL_MS <= 0) return STALL_NOTICE_MS;
-  if (!hasModelOutput(teammate) && !teammate.activeTool) return SILENT_STALL_MS;
-  return STALL_NOTICE_MS;
-}
-
-function usageLine(usage: WorkerUsage | undefined): string {
-  if (!usage) return "";
-  return ` Lifetime usage: ${usage.totalTokens} tokens, $${usage.cost.toFixed(4)}.`;
-}
-
-/** Stall notice body with the diagnostics a leader needs to decide: silence
- * duration, spawn age, lifetime usage, and — for the zero-output provider-hang
- * signature — the remedy that actually works (shutdown + respawn). */
-export function stallNoticeBody(
-  teammate: Pick<Teammate, "name" | "createdAt" | "activeTool" | "modelOutputSeen" | "usage">,
-  silenceMs: number,
-  now = Date.now(),
-): string {
-  const head = `@${teammate.name} has been silent for ${formatSilenceDuration(silenceMs)} (spawn age ${formatSilenceDuration(Math.max(0, now - teammate.createdAt))}).`;
-  if (!hasModelOutput(teammate) && !teammate.activeTool) {
-    return `${head} No model output received yet.${usageLine(teammate.usage)} An in-flight request stuck on the provider will not recover by steering; recovery usually means shutting this teammate down and respawning a successor (optionally pinning another model). Decide: keep waiting, steer again, or shut it down.`;
-  }
-  const toolNote = teammate.activeTool ? ` Tool still running: ${teammate.activeTool}.` : "";
-  return `${head}${toolNote}${usageLine(teammate.usage)} The child may be blocked in a provider or tool call; steer delivery is uncertain. Decide: keep waiting, steer again, or shut it down (and respawn a successor with context from the original kickoff, its mailbox reports, board claims, and the /agent-teams detail transcript).`;
+/** Console-only silence threshold for the roster "stalled" marker. */
+export function stallThresholdMs(_teammate: Pick<Teammate, "modelOutputSeen" | "activeTool">): number {
+  return STALL_SILENCE_MS;
 }
 
 let livePollTimer: ReturnType<typeof setInterval> | undefined;
@@ -185,20 +153,81 @@ let boardFile = "";
 let leaderCwd = "";
 /** Live view of the leader session's current model, resolved at spawn time. */
 let leaderModelRef: () => string | undefined = () => undefined;
-let sendUpdate: (report: FollowUpReport) => void = () => {};
-let archiveQueuedReports: (spawnId: string) => FollowUpReport[] = () => [];
+let leaderThinkingLevelRef: () => LeaderThinkingLevel | undefined = () => undefined;
+let sendUpdate: (report: LeaderReport) => void = () => {};
 let notifyChange: () => void = () => {};
 
 const pendingShutdowns = new Set<string>();
+const confirmedStopTimes = new Map<string, number>();
+/** Confirmed-stop and finish bookkeeping is per incarnation or per assignment
+ *  attempt, so a long session accumulates one entry each. Keep the same bounded
+ *  FIFO shape the peer-delivery dedupe uses instead of growing without limit. */
+const MAX_RUNTIME_BOOKKEEPING_ENTRIES = 512;
+
+function rememberBounded<T>(entries: Map<string, T> | Set<string>, key: string, value?: T): void {
+  if (entries instanceof Map) entries.set(key, value as T);
+  else entries.add(key);
+  for (const oldest of entries.keys()) {
+    if (entries.size <= MAX_RUNTIME_BOOKKEEPING_ENTRIES) break;
+    entries.delete(oldest);
+  }
+}
+const closeFinalizations = new Map<string, Promise<void>>();
+
+export function getConfirmedStopTime(spawnId: string): number | undefined {
+  return confirmedStopTimes.get(spawnId);
+}
 /** Task ids under verification, bound to one exact submission via token so a
  *  release/re-claim or newer submission invalidates any older in-flight gate. */
-const verifyingTasks = new Map<string, { worker: string; spawnId: string; submissionId: string; token: string }>();
+const verifyingTasks = new Map<string, { worker: string; spawnId: string; assignmentId: string; submissionId: string; token: string }>();
+/** In-flight gate reviewers by task id. Invalidating a holding's authority must
+ *  also stop its reviewer child, not merely discard the verdict it returns. */
+const verifyAborts = new Map<string, { controller: AbortController; submissionId: string }>();
+
+/** Drop any in-flight gate for one task and stop its reviewer process. Every
+ *  invalidation path uses this so Work authority and child processes cannot
+ *  diverge. */
+function invalidateVerifyGate(taskId: string): void {
+  verifyingTasks.delete(taskId);
+  const active = verifyAborts.get(taskId);
+  if (!active) return;
+  verifyAborts.delete(taskId);
+  active.controller.abort();
+}
+
+/** Start one gate attempt, aborting any earlier reviewer for the same task. */
+function runVerifyGate(
+  intent: import("./types").TaskIntent,
+  subject: string,
+  submissionId: string,
+  token: string,
+  input: VerifyReviewInput,
+): void {
+  const previous = verifyAborts.get(intent.taskId);
+  if (previous) {
+    verifyAborts.delete(intent.taskId);
+    previous.controller.abort();
+  }
+  const controller = new AbortController();
+  verifyAborts.set(intent.taskId, { controller, submissionId });
+  // A reviewer crash is a concrete failed gate. A missing verdict is handled
+  // separately as inconclusive so prose-format drift cannot count as a defect.
+  Promise.resolve()
+    .then(() => verifyGateRunner({ ...input, signal: controller.signal }))
+    .then((outcome) => resolveGateOutcome(intent, subject, submissionId, token, outcome))
+    .catch((error) => resolveGateOutcome(intent, subject, submissionId, token, {
+      kind: "fail",
+      detail: truncated(`(completion review crashed) ${error instanceof Error ? error.message : String(error)}`),
+    }));
+}
+type PendingSubmission = import("./types").TaskIntent & { assignmentId: string; verify: string | undefined };
+/** Submitted Work waits for its authoring Worker to settle before a gate can
+ * inspect its files. This applies to direct automatic and board submissions. */
+const pendingSubmissions = new Map<string, PendingSubmission>();
 /** Idle nudges already fired per teammate incarnation (one per transition). */
 const idleNudgesSent = new Set<string>();
-/** One finish entry per spawn incarnation; repeated terminal reports stay ordinary report rows. */
+/** One finish entry per assignment attempt; repeated terminal reports stay ordinary report rows. */
 const announcedFinishKeys = new Set<string>();
-/** Incarnations whose terminal report reached the leader pipeline, queued or dispatched. */
-const terminalReportKeys = new Set<string>();
 /** Consecutive verify failures per taskId:spawnId holder incarnation. */
 const verifyFailures = new Map<string, VerifyFailureRecord>();
 /** Self-finalize requests delivered per teammate incarnation before escalating to the leader. */
@@ -209,28 +238,58 @@ const liveWorktrees = new Map<string, ReturnType<typeof createWorktree>>();
 // ── Lifecycle ─────────────────────────────────────────────────────
 
 export interface MachineHooks {
-  sendUpdate: (report: FollowUpReport) => void;
-  /** Suppress reports whose delivery remains harness-owned when shutdown starts. */
-  archiveQueuedReports?: (spawnId: string) => FollowUpReport[];
+  sendUpdate: (report: LeaderReport) => void;
   notifyChange: () => void;
 }
 
 export function initTeamMachine(
-  ctx: Pick<ExtensionContext, "sessionManager" | "cwd" | "model">,
+  ctx: Pick<ExtensionContext, "sessionManager" | "cwd" | "model" | "thinkingLevel">,
   hooks: MachineHooks,
 ): void {
   generation++;
   leaderCwd = ctx.cwd || process.cwd();
   leaderModelRef = () => (ctx.model ? modelLabel(ctx.model) : undefined);
+  leaderThinkingLevelRef = () => ctx.thinkingLevel;
   const sessionFile = ctx.sessionManager?.getSessionFile();
   runtimeStateFile = stateFilePath(sessionFile, leaderCwd);
   boardFile = boardFilePath(sessionFile, leaderCwd);
   sendUpdate = hooks.sendUpdate;
-  archiveQueuedReports = hooks.archiveQueuedReports ?? (() => []);
   notifyChange = hooks.notifyChange;
-  // Resume: reload a persisted board; claims die with their holders.
-  const persisted = readBoardFile(boardFile);
-  if (persisted) loadBoard(persisted.tasks);
+  // The board and runtime dir are keyed per session, so two Leader processes
+  // holding the same session would overwrite each other's single-writer state.
+  // Detection is a report, not a block: the harness never takes ownership away
+  // from a session the user may legitimately be resuming.
+  claimLeaderLease();
+  // Resume: reload a persisted board; claims die with their holders. A board
+  // that cannot be loaded is archived rather than silently discarded or allowed
+  // to prevent extension reload.
+  try {
+    const persisted = readBoardFile(boardFile);
+    if (persisted) loadBoard(persisted.tasks);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    let preservation: string;
+    try {
+      const archived = `${boardFile}.incompatible-${Date.now()}`;
+      fs.renameSync(boardFile, archived);
+      preservation = `Archived preserved snapshot: ${archived}`;
+    } catch {
+      // An unusable agents directory must still not turn preservation into a
+      // fatal startup error: report where the snapshot stayed instead.
+      preservation = `The preserved snapshot could not be archived and stays in place: ${boardFile}`;
+    }
+    deliverToLeader({ from: "harness", subject: "Incompatible Work snapshot", body: `${detail}\n${preservation}` });
+  }
+}
+
+/** Re-bind the leader context closures after a mid-session model or
+ *  thinking-level switch, so later spawns resolve against the current
+ *  session configuration instead of the session_start snapshot. */
+export function syncLeaderContext(
+  ctx: Pick<ExtensionContext, "model" | "thinkingLevel">,
+): void {
+  leaderModelRef = () => (ctx.model ? modelLabel(ctx.model) : undefined);
+  leaderThinkingLevelRef = () => ctx.thinkingLevel;
 }
 
 export function shutdownTeamMachine(): void {
@@ -241,31 +300,43 @@ export function shutdownTeamMachine(): void {
   boardFile = "";
   leaderCwd = "";
   leaderModelRef = () => undefined;
+  leaderThinkingLevelRef = () => undefined;
   setVerifyGateRunner(undefined);
   sendUpdate = () => {};
-  archiveQueuedReports = () => [];
   notifyChange = () => {};
   pendingShutdowns.clear();
+  confirmedStopTimes.clear();
+  closeFinalizations.clear();
   verifyingTasks.clear();
+  for (const active of verifyAborts.values()) active.controller.abort();
+  verifyAborts.clear();
+  pendingSubmissions.clear();
   idleNudgesSent.clear();
   selfFinalizeAttempts.clear();
   pendingDeliveries.clear();
   verifyFailures.clear();
   inconclusiveParks.clear();
   verifyFailureParks.clear();
+  unexpectedExecutionParks.clear();
   announcedFinishKeys.clear();
-  terminalReportKeys.clear();
+  snapshotFailure = undefined;
+  writtenStateRevision = -1;
+  writtenRosterRevision = -1;
+  writtenBoardRevision = -1;
+  writtenProgressRevision = -1;
+  lastStateWriteAt = 0;
 }
 
 // ── Spawn model resolution ────────────────────────────────────
 
 /** How a spawn's effective model was chosen. */
-export type SpawnModelSource = "pin" | "inherit" | "team-default" | "none";
+export type SpawnModelSource = "pin" | "inherit" | "team-default" | "leader-session" | "none";
 
 /**
  * Resolve the effective spawn model. Precedence: explicit role pin beats the
  * `inherit` alias (the leader session's current model), which beats the team
- * default set from the console; with none of these Pi picks its own default.
+ * default set from the console; if unset, falls back to the current session's
+ * model; with none of these Pi picks its own default.
  * The value is resolved at spawn time so mid-session leader model switches
  * apply to later spawns.
  */
@@ -279,12 +350,30 @@ export function resolveSpawnModel(
   if (pin && leaderModel) return { model: leaderModel, source: "inherit" };
   const fallback = teamDefault?.trim();
   if (fallback) return { model: fallback, source: "team-default" };
+  const currentLeader = leaderModel?.trim();
+  if (currentLeader) return { model: currentLeader, source: "leader-session" };
   return { model: undefined, source: "none" };
 }
 
 /** The leader session's current model reference, when one is selected. */
 export function currentLeaderModelRef(): string | undefined {
-  return leaderModelRef();
+  const fromRef = leaderModelRef();
+  if (fromRef) return fromRef;
+  if (process.env.PI_PROVIDER && process.env.PI_MODEL) {
+    return `${process.env.PI_PROVIDER}/${process.env.PI_MODEL}`;
+  }
+  return process.env.PI_MODEL;
+}
+
+/** The leader session's current thinking level, when one is selected. */
+export function currentLeaderThinkingLevel(): LeaderThinkingLevel | undefined {
+  const fromRef = leaderThinkingLevelRef();
+  if (fromRef) return fromRef;
+  const fromEnv = process.env.PI_REASONING_LEVEL?.trim();
+  if (fromEnv && THINKING_LEVELS.includes(fromEnv as LeaderThinkingLevel)) {
+    return fromEnv as LeaderThinkingLevel;
+  }
+  return undefined;
 }
 
 /** Terminate every resident teammate; returns unconfirmed-close diagnostics. */
@@ -296,7 +385,7 @@ export async function teardownTeammates(): Promise<string[]> {
   const results = await terminateAllTeammates();
   const diagnostics: string[] = [];
   for (const result of results) {
-    if (!result.confirmedClosed) diagnostics.push(`Teammate ${result.name} could not be confirmed closed.`);
+    if (!result.confirmedClosed) diagnostics.push(`Agent ${result.name} could not be confirmed closed.`);
     updateTeammate(result.name, { status: "stopped" });
   }
   return diagnostics;
@@ -319,22 +408,115 @@ export function runtimeDirPath(): string {
   return file.slice(0, Math.max(file.lastIndexOf("/"), 0));
 }
 
+/** Consecutive snapshot writes that failed. The tick retries, so only a
+ *  persistent failure (no successful write in this many attempts) is reported
+ *  instead of being silently invisible. */
+const SNAPSHOT_FAILURE_REPORT_AFTER = 3;
+let snapshotFailure: { count: number; reported: boolean; detail: string } | undefined;
+/** Revisions already on disk. -1 makes the first flush after a (re)init write
+ *  every artifact. */
+let writtenStateRevision = -1;
+let writtenRosterRevision = -1;
+let writtenBoardRevision = -1;
+let writtenProgressRevision = -1;
+let lastStateWriteAt = 0;
+/** Roughly 2 poll ticks: the debug snapshot follows progress, but not per token. */
+export const STATE_SNAPSHOT_MIN_INTERVAL_MS = 1_000;
+
+/** Runtime dir that holds the leader lease for the current session. */
+function leaderLockPath(stateFile: string): string {
+  return path.join(path.dirname(stateFile), "leader.pid");
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/** Record this process as the session's Leader, warning when another live one
+ *  still holds the same session. The lease dies with the runtime dir. */
+function claimLeaderLease(): void {
+  const lock = leaderLockPath(requireStateFile());
+  let previous: number | undefined;
+  try {
+    const parsed = Number(fs.readFileSync(lock, "utf-8").trim());
+    if (Number.isInteger(parsed) && parsed > 0 && parsed !== process.pid) previous = parsed;
+  } catch {
+    // No lease yet, or an unreadable one: this process takes it either way.
+  }
+  try {
+    fs.mkdirSync(path.dirname(lock), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(lock, `${process.pid}\n`, { encoding: "utf-8", mode: 0o600 });
+  } catch {
+    return;
+  }
+  if (previous !== undefined && isProcessAlive(previous)) {
+    deliverToLeader({
+      from: "harness",
+      subject: "Another Leader process shares this session",
+      body: `Leader process ${previous} is still running for this session's Work directory. Two Leaders writing one session would overwrite each other's Work state; finish or stop the other Pi session (or confirm it exited) before editing Work here.`,
+    });
+  }
+}
+
 function flushSnapshots(): void {
   const stateFile = requireStateFile();
+  const rosterRev = rosterRevision();
+  const boardRev = boardRevision();
+  const stateRev = stateRevision();
+  const progressRev = progressRevision();
+  const needsRoster = rosterRev !== writtenRosterRevision;
+  const needsBoard = boardRev !== writtenBoardRevision;
+  // The whole-state file exists for forensics; nothing in the runtime reads it
+  // back. It still tracks streamed progress, but at a bounded rate instead of
+  // rewriting the state on every token.
+  const needsState = stateRev !== writtenStateRevision
+    || (progressRev !== writtenProgressRevision && Date.now() - lastStateWriteAt >= STATE_SNAPSHOT_MIN_INTERVAL_MS);
+  if (!needsRoster && !needsBoard && !needsState) return;
   try {
-    writeStateFile(stateFile, getState());
-    writeRoster(rosterPath(stateFile), livingTeammates().map((t) => ({
-      name: t.name,
-      agent: t.agent,
-      status: t.status,
-      tools: t.tools,
-      currentTaskId: t.currentTaskId,
-      assignment: t.assignment,
-    })));
-    if (boardFile) writeBoardFile(boardFile, getState().tasks);
-    clearStateDirty();
-  } catch {
-    // Keep the dirty bit set so the next poll retries the snapshot.
+    if (needsState) writeStateFile(stateFile, getState());
+    if (needsRoster) {
+      writeRoster(rosterPath(stateFile), livingTeammates().map((t) => ({
+        name: t.name,
+        agent: t.agent,
+        spawnId: t.spawnId,
+        status: t.status,
+        tools: t.tools,
+        currentTaskId: t.currentTaskId,
+        assignment: t.assignment,
+      })));
+    }
+    if (needsBoard && boardFile) writeBoardFile(boardFile, getState().tasks);
+    // Only a fully successful flush advances the revisions, so a failed write
+    // stays dirty and the next poll retries it.
+    if (needsState) {
+      writtenStateRevision = stateRev;
+      writtenProgressRevision = progressRev;
+      lastStateWriteAt = Date.now();
+    }
+    if (needsRoster) writtenRosterRevision = rosterRev;
+    if (needsBoard) writtenBoardRevision = boardRev;
+    snapshotFailure = undefined;
+  } catch (error) {
+    // The next poll retries. A transient failure stays quiet, but a persistent
+    // one is surfaced once: durable Work state silently diverging from memory
+    // is a decision the Leader must be able to make.
+    const detail = error instanceof Error ? error.message : String(error);
+    const count = (snapshotFailure?.count ?? 0) + 1;
+    const alreadyReported = snapshotFailure?.reported ?? false;
+    snapshotFailure = { count, reported: alreadyReported, detail };
+    if (count >= SNAPSHOT_FAILURE_REPORT_AFTER && !alreadyReported) {
+      snapshotFailure.reported = true;
+      deliverToLeader({
+        from: "harness",
+        subject: "Work snapshot writes are failing",
+        body: `The durable Work snapshot under ${path.dirname(stateFile)} has failed ${count} consecutive writes (${detail}). In-memory Work state is still authoritative for this session; the files on disk are stale. Check disk space and permissions before ending the session.`,
+      });
+    }
   }
 }
 
@@ -364,7 +546,6 @@ function tick(): void {
   processTaskIntents();
   routePeerInboxes();
   wakeIdleTeammates();
-  checkStalledTeammates();
   flushSnapshots();
   ensureLivePoll();
   notifyChange();
@@ -375,15 +556,21 @@ function tick(): void {
 export function spawnTeammate(input: {
   name: string;
   agent: string;
+  workId?: string;
+  /** Internal binding of an existing Work Item, never exposed as a public field. */
+  existingWorkId?: string;
+  context?: ResidentSpawnOptions["context"];
+  model?: string;
   prompt?: string;
   resources?: string[];
+  verify?: string;
   handoffFrom?: string;
   definition?: Omit<AgentDefinitionInput, "name" | "tools"> & {
     tools?: string[];
     persist?: boolean;
     persistScope?: "project" | "project-local";
   };
-}): { ok: true; teammate: Teammate } | { ok: false; error: string } {
+}): { ok: true; teammate: Teammate; readiness?: Promise<string | undefined> } | { ok: false; error: string } {
   const stateFile = requireStateFile();
   const invalid = validateSpawnInput(input);
   if (invalid) return { ok: false, error: invalid };
@@ -394,6 +581,10 @@ export function spawnTeammate(input: {
       return { ok: false, error: `Cannot hand off from living @${input.handoffFrom}. Shut it down or wait for it to stop before spawning a successor.` };
     }
   }
+  const existingWork = input.existingWorkId ? getState().tasks[input.existingWorkId] : undefined;
+  if (input.existingWorkId && (!existingWork || existingWork.status !== "pending" || !taskDependenciesMet(existingWork))) {
+    return { ok: false, error: `Work Item "${input.existingWorkId}" is not pending and claimable.` };
+  }
   const resolved = resolveAgent(input.agent, leaderCwd);
   // Reject tool ids the bare child could never grant before any side effect:
   // a silent --tools drop here is how reviewers end up blind mid-audit.
@@ -434,9 +625,11 @@ export function spawnTeammate(input: {
 
   const spawnId = randomUUID();
   const effectiveKickoff = buildSuccessorHandoff(input.prompt, input.handoffFrom);
-  const directResources = effectiveKickoff?.trim()
-    ? resolveDirectResources(input.resources, input.handoffFrom)
-    : [];
+  const directResources = input.existingWorkId
+    ? existingWork!.resources
+    : effectiveKickoff?.trim()
+      ? resolveDirectResources(input.resources, input.handoffFrom)
+      : [];
   const conflict = activeAssignmentConflict(directResources);
   if (conflict) {
     discardWorktreeQuietly(input.name);
@@ -448,48 +641,87 @@ export function spawnTeammate(input: {
     return { ok: false, error: registered.error };
   }
 
-  const spawnModel = resolveSpawnModel(agent.model, getTeamDefaultModel(), leaderModelRef());
+  const spawnModel = resolveSpawnModel(input.model ?? agent.model, getTeamDefaultModel(), currentLeaderModelRef());
   // Record the grant before the first wake: a role derived without tools shows
   // its narrow capability-only allowlist right on the spawn surface.
   const assignment = directAssignment(effectiveKickoff, directResources, spawnId);
+  if (assignment) {
+    const directWork = input.existingWorkId
+      ? reclaimDirectWork(input.existingWorkId, input.name, assignment, "pending")
+      : createDirectWork({
+        id: getTeammate(input.name)?.workId ?? `work:${spawnId}`,
+        subject: effectiveKickoff ? messageTitle(effectiveKickoff) : "Direct work",
+        description: effectiveKickoff,
+        resources: directResources,
+        verify: input.verify,
+        workerName: input.name,
+        assignment,
+      });
+    if (!directWork.ok) {
+      updateTeammate(input.name, { status: "stopped" });
+      discardWorktreeQuietly(input.name);
+      return { ok: false, error: directWork.error };
+    }
+  }
   updateTeammate(input.name, {
     model: spawnModel.model,
+    context: input.context === undefined ? "fresh" : "fork",
     tools: resolveWorkerTools(agent.tools),
-    assignment,
+    ...(assignment ? {} : { assignment }),
   });
   // Flush before the kickoff is written: a fast child must not read a stale
   // worker-readable roster missing its own entry or tool grant.
   publishStateSnapshot();
 
+  // Settles from native control events, never a polling loop or a model turn.
+  // Resolve failures as values so internal synchronous spawn callers cannot
+  // produce an unhandled rejection when they do not await startup.
+  let settleReadiness!: (error: string | undefined) => void;
+  const readiness = new Promise<string | undefined>((resolve) => { settleReadiness = resolve; });
   const started = spawnResident({
     workerName: input.name,
-    description: buildKickoffPrompt(
+    description: assignment ? `[agent-teams-assignment:${assignment.id}]\n` + buildKickoffPrompt(
       input.name,
       input.agent,
       agent.prompt,
       effectiveKickoff,
       isolation,
-    ),
+    ) : undefined,
     model: spawnModel.model,
+    thinking: currentLeaderThinkingLevel(),
+    context: input.context,
     tools: agent.tools,
     cwd: workerCwd,
     env: teammateEnv(stateFile, input, spawnId, agent.verify),
-    onUpdate: (progress) => applyProgress(input.name, spawnId, progress),
-    onExit: (result) => void handleTeammateClose(input.name, spawnId, result),
+    onUpdate: (progress) => {
+      applyProgress(input.name, spawnId, progress);
+      if (progress.controlError) settleReadiness(progress.controlError);
+      else if (progress.ready) settleReadiness(undefined);
+    },
+    onError: (error) => {
+      settleReadiness(`Resident startup readiness failed: ${error.message}`);
+      if (getTeammate(input.name)?.spawnId !== spawnId) return;
+      if (input.existingWorkId) releaseTask(input.existingWorkId, `Agent failed to start: ${error.message}`);
+      failSpawn(input.name, error.message, input.existingWorkId);
+    },
+    onExit: (result) => {
+      settleReadiness("Resident exited before startup readiness was acknowledged.");
+      closeFinalizations.set(spawnId, handleTeammateClose(input.name, spawnId, result));
+    },
   });
   if ("error" in started) {
-    failSpawn(input.name, started.error);
+    if (input.existingWorkId) releaseTask(input.existingWorkId, `Agent failed to start: ${started.error}`);
+    else if (assignment) discardDirectWork(getTeammate(input.name)?.workId ?? `work:${spawnId}`, input.name);
+    failSpawn(input.name, started.error, input.existingWorkId);
     return { ok: false, error: started.error };
   }
   updateTeammate(input.name, { pid: started.pid });
-  // Status stays "starting" until real stream events arrive: every spawned
-  // teammate runs a kickoff turn, so marking prompt-less spawns idle here used
-  // to mislabel an actively-running turn as idle and misroute deliveries
-  // (queued instead of steered, then lost inside the running turn).
+  // Keep starting until model activity or the unassigned child's native
+  // readiness acknowledgement arrives; spawning alone does not prove idle.
   publishStateSnapshot();
   ensureLivePoll();
   notifyChange();
-  return { ok: true, teammate: getTeammate(input.name)! };
+  return { ok: true, teammate: getTeammate(input.name)!, ...(assignment ? {} : { readiness }) };
 }
 
 /** True when a spawn's inline definition should create or replace the role:
@@ -519,7 +751,7 @@ export function unknownAgentError(name: string, cwd: string): string {
     `Agent "${name}" not found in any scope.`,
     `Checked: ${cwd}/.pi/agents/<name>.local.md, ${cwd}/.pi/agents/<name>.md, ${path.join(getAgentDir(), "agents")}, and in-memory session roles.`,
     'The available-agents list in your guidance may be stale: definition files can change mid-session (for example removed by a parallel session).',
-    'Recover by retrying teammate_spawn with name and an existing agent role id, or with name, a new agent role id, and an inline definition derived from references/agent-roles.md that includes description and prompt.',
+    'Recover by retrying agent action=delegate or start with name and an existing agent role id, or with name, a new agent role id, and an inline definition derived from references/agent-roles.md that includes description and prompt.',
     `Available now: ${available.length > 0 ? available.join(", ") : "(none)"}.`,
   ].join(' ');
 }
@@ -531,14 +763,11 @@ function validateSpawnInput(input: { name: string }): string | undefined {
   if (livingTeammates().some((t) => t.name === input.name)) {
     return `A living teammate named "${input.name}" already exists.`;
   }
-  if (livingTeammates().length >= MAX_SESSION_WORKERS) {
-    return `Session cap reached: at most ${MAX_SESSION_WORKERS} teammates may be alive at once.`;
-  }
   return undefined;
 }
 
 function newTeammate(
-  input: { name: string; agent: string },
+  input: { name: string; agent: string; workId?: string },
 
   spawnId: string,
   isolation: Teammate["isolation"],
@@ -548,6 +777,7 @@ function newTeammate(
     name: input.name,
     agent: input.agent,
     spawnId,
+    workId: input.workId,
     pid: 0,
     status: "starting",
     cwd: workerCwd,
@@ -634,11 +864,21 @@ export function buildKickoffPrompt(
   ].filter(Boolean).join(" ");
   const roleSection = `=== ROLE PROMPT (${agentName}) ===\n${rolePrompt}`;
   const taskSection = kickoff?.trim()
-    ? `=== KICKOFF TASK ===\n${kickoff.trim()}\n\nExecute this assigned task directly. Do not call task_list or check the task board unless this task explicitly instructs you to do so.`
-    : "=== KICKOFF TASK ===\n(none yet — check the task board with task_list and claim suitable work with task_claim)";
+    ? `=== KICKOFF TASK ===\n${kickoff.trim()}\n\nExecute this assigned task directly. Do not call work action=list or check the task board unless this task explicitly instructs you to do so.`
+    : "=== KICKOFF TASK ===\n(none yet — inspect Work with action=list and claim suitable Work with action=claim)";
   return `${header}\n\n${roleSection}\n\n${taskSection}`;
 }
 
+function buildFreshAssignmentPrompt(teammate: Teammate, assignmentId: string, task: string): string {
+  return `[agent-teams-assignment:${assignmentId}]\n${buildKickoffPrompt(
+    teammate.name,
+    teammate.agent,
+    resolveAgent(teammate.agent, leaderCwd)?.prompt ?? "",
+    task,
+    teammate.isolation,
+  )}`;
+}
+
 function discardWorktreeQuietly(name: string): void {
   const handle = liveWorktrees.get(name);
   if (!handle || "error" in handle) return;
@@ -651,62 +891,65 @@ function boardDirectory(): string {
   return path.dirname(boardFile);
 }
 
-function applyProgress(name: string, spawnId: string, progress: {
+export function applyProgress(name: string, spawnId: string, progress: {
   text: string;
   activeTool?: string;
   liveThinking?: string;
   turns: number;
   finalResponse?: boolean;
   modelOutputSeen?: boolean;
+  ready?: boolean;
   usage?: WorkerUsage;
+  controlError?: string;
 }): void {
   const teammate = getTeammate(name);
   // A stale callback from an older incarnation must not touch the current one.
   if (!teammate || teammate.spawnId !== spawnId || teammate.status === "stopped") return;
+  if (progress.controlError) {
+    updateTeammate(name, { error: progress.controlError });
+    deliverDiagnostic(name, progress.controlError);
+    sendUpdate({ teammate: name, spawnId, body: progress.controlError, origin: "harness", harnessEvent: { type: "control-rejected", subject: `@${name} control rejected` }, finished: false });
+  }
   updateTeammateProgress(name, teammate.spawnId, {
     liveText: progress.text,
     activeTool: progress.activeTool,
     liveThinking: progress.liveThinking,
     turns: progress.turns,
-    sequenceEnded: progress.finalResponse === true ? true : undefined,
+    sequenceEnded: progress.finalResponse,
     modelOutputSeen: progress.modelOutputSeen,
     usage: progress.usage,
   });
-  updateTeammate(name, { lastOutputAt: Date.now(), stallNoticeSentAt: undefined });
+  updateTeammate(name, { lastOutputAt: Date.now(), ...(progress.finalResponse === false ? { status: "working" } : {}) });
+  if (progress.finalResponse === false && teammate.currentTaskId && verifyingTasks.has(teammate.currentTaskId)) {
+    const holding = `${teammate.currentTaskId}:${spawnId}`;
+    invalidateVerifyGate(teammate.currentTaskId);
+    unexpectedExecutionParks.add(holding);
+    sendUpdate({
+      teammate: name,
+      spawnId,
+      origin: "harness",
+      harnessEvent: { type: "review-invalidated", subject: `Verification invalidated · ${getTask(teammate.currentTaskId)?.subject ?? "Work"}` },
+      body: `Observed new execution for @${name} while verification was in flight. The review was invalidated; Work "${teammate.currentTaskId}" remains held until explicit leader direction authorizes a revision.`,
+      finished: false,
+    });
+  }
   if (progress.finalResponse && teammate.status !== "idle") {
     updateTeammate(name, { status: "idle", activeTool: undefined });
+    drainTeammateOutboxes(name);
+    processTaskIntents();
+    const pending = pendingSubmissions.get(name);
+    if (pending?.spawnId === spawnId && getTeammate(name)?.assignment?.id === pending.assignmentId) {
+      pendingSubmissions.delete(name);
+      archiveDeferredDeliveries(getTeammate(name)!);
+      beginVerifyOrComplete(pending, pending.verify);
+    }
     nudgeIfUnfinalized(name, spawnId);
   }
-  ensureLivePoll();
-}
-
-export function formatAgentHealthReport(
-  state: "stalled",
-  teammate: Pick<Teammate, "name" | "agent">,
-  body: string,
-  silenceMs: number,
-): FollowUpReport {
-  return {
-    teammate: teammate.name,
-    agent: teammate.agent,
-    body,
-    finished: false,
-    health: { state, silenceMs },
-  };
-}
-
-function checkStalledTeammates(now = Date.now()): void {
-  if (STALL_NOTICE_MS <= 0) return;
-  for (const teammate of livingTeammates()) {
-    if (teammate.status !== "working" && teammate.status !== "starting") continue;
-    const silence = stallSilenceMs(teammate, now);
-    if (silence === undefined || teammate.stallNoticeSentAt !== undefined) continue;
-    if (silence < stallThresholdMs(teammate)) continue;
-    const body = stallNoticeBody(teammate, silence, now);
-    updateTeammate(teammate.name, { stallNoticeSentAt: now });
-    deliverToLeader({ from: "harness", subject: `Possible stall: @${teammate.name}`, body });
-    sendUpdate(formatAgentHealthReport("stalled", teammate, body, silence));
+  if (progress.ready || progress.controlError) {
+    publishStateSnapshot();
+    notifyChange();
   }
+  ensureLivePoll();
 }
 
 interface VerifyFailureRecord {
@@ -716,64 +959,39 @@ interface VerifyFailureRecord {
 
 /** One verdict-only retry per exact verify submission. */
 const inconclusiveVerifications = new Map<string, number>();
-/** Two inconclusive reviews park a holding until the leader explicitly steers it. */
+/** Two inconclusive reviews park a holding until explicit Work recovery. */
 const inconclusiveParks = new Map<string, { worker: string; spawnId: string }>();
-/** Two explicit verify failures also require leader direction before retry. */
+/** Repeated verify failures retain authority until explicit Work recovery. */
 const verifyFailureParks = new Map<string, { worker: string; spawnId: string }>();
+/** Owner execution observed during review; explicit Leader recovery is required. */
+const unexpectedExecutionParks = new Set<string>();
 
-/** Record one finish entry per spawn incarnation; later terminal reports from
- *  the same resident stay ordinary report rows. */
-export function markTeammateFinished(
-  report: Pick<FollowUpReport, "teammate" | "agent" | "spawnId" | "finished">,
-): boolean {
-  if (!report.finished) return false;
-  const name = report.teammate ?? report.agent ?? "teammate";
-  const key = `${name}:${report.spawnId ?? "session"}`;
-  if (announcedFinishKeys.has(key)) return false;
-  announcedFinishKeys.add(key);
-  return true;
-}
+type FinishIdentity = Pick<LeaderReport, "teammate" | "agent" | "spawnId" | "assignmentId" | "finished">;
 
-/** True when this teammate's current incarnation already announced its finish entry. */
-export function hasAnnouncedFinish(name: string): boolean {
-  const spawnId = getTeammate(name)?.spawnId;
-  return announcedFinishKeys.has(`${name}:${spawnId ?? "session"}`);
+function finishKey(report: FinishIdentity): string {
+  return `${report.teammate ?? report.agent ?? "teammate"}:${report.spawnId ?? "session"}:${report.assignmentId ?? "unassigned"}`;
 }
 
-/** Remember at send time that this incarnation produced a terminal report, so
- *  end-of-life suppression covers reports still queued for dispatch. */
-export function recordTerminalReport(
-  report: Pick<FollowUpReport, "teammate" | "agent" | "spawnId" | "finished">,
-): void {
-  if (!report.finished) return;
-  const name = report.teammate ?? report.agent ?? "teammate";
-  terminalReportKeys.add(`${name}:${report.spawnId ?? "session"}`);
-}
-
-/** True when this teammate's current incarnation has a terminal report in the
- *  leader pipeline, whether or not its finish entry has been dispatched yet. */
-export function hasTerminalReport(name: string): boolean {
-  const spawnId = getTeammate(name)?.spawnId;
-  return terminalReportKeys.has(`${name}:${spawnId ?? "session"}`);
+/** Announce each assignment attempt once, including later work in the same process. */
+export function markTeammateFinished(report: FinishIdentity): boolean {
+  if (!report.finished) return false;
+  const key = finishKey(report);
+  if (announcedFinishKeys.has(key)) return false;
+  rememberBounded(announcedFinishKeys, key);
+  return true;
 }
 
-/** True when the teammate's last leader-bound report lacks a terminal status. */
+/** Only an open current assignment can owe a final result. */
 export function hasUnfinalizedReport(name: string): boolean {
-  const mailbox = getState().leaderMailbox;
-  for (let i = mailbox.length - 1; i >= 0; i--) {
-    if (mailbox[i].from !== name) continue;
-    return mailbox[i].status !== "completed" && mailbox[i].status !== "failed";
-  }
-  return false;
+  const teammate = getTeammate(name);
+  return Boolean(teammate?.assignment && !teammate.assignment.closed
+    && !teammate.reportSequenceEnded && !verificationFrozen(teammate));
 }
 
 /** One light reminder per idle transition when work looks unfinished. */
 function nudgeIfUnfinalized(name: string, spawnId: string): void {
-  const key = `${name}:${spawnId}`;
-  // The terminal report may have been written to the outbox file but not yet
-  // drained into the leader mailbox by the next tick; drain before deciding.
-  drainTeammateOutboxes();
   if (!hasUnfinalizedReport(name)) return;
+  const key = `${name}:${spawnId}:${getTeammate(name)?.assignment?.id}`;
   if (!selfFinalizeAttempts.has(key)) {
     // First miss: give the worker one chance to fix its own bookkeeping
     // before bothering the leader. The inbox message wakes it on the next tick.
@@ -781,13 +999,13 @@ function nudgeIfUnfinalized(name: string, spawnId: string): void {
     deliverFeedback(
       name,
       "Assignment not finalized",
-      'Your latest message to the leader carried no terminal status. Send send_message(to="leader", message=...) now with status="completed" or status="failed" summarizing your final result.',
+      `Current assignment "${getTeammate(name)?.assignment?.id ?? "unassigned"}" has no automatic final result yet. Return a final answer or submit the current Work outcome.`,
     );
     return;
   }
   if (idleNudgesSent.has(key)) return;
   idleNudgesSent.add(key);
-  const reminder = `@${name} is now idle but its last report was not marked status="completed" or "failed". Its conclusions may be stuck in the mailbox — ask it to finalize or inspect the /agent-teams console.`;
+  const reminder = `@${name} is idle but current assignment "${getTeammate(name)?.assignment?.id ?? "unassigned"}" has no terminal report after one finalization request. Decide whether to resume or release the assignment.`;
   deliverToLeader({ from: "harness", subject: `Idle without terminal report: @${name}`, body: reminder });
   sendUpdate({
     teammate: name,
@@ -798,8 +1016,13 @@ function nudgeIfUnfinalized(name: string, spawnId: string): void {
   });
 }
 
-function failSpawn(name: string, error: string): void {
+function failSpawn(name: string, error: string, existingWorkId?: string): void {
   const teammate = getTeammate(name);
+  if (!existingWorkId && teammate?.assignment?.kind === "direct" && teammate.currentTaskId) {
+    discardDirectWork(teammate.currentTaskId, name);
+  } else {
+    releaseTasksOf(name, `Agent failed to start: ${error}`);
+  }
   discardWorktreeQuietly(name);
   updateTeammate(name, { status: "stopped", error });
   if (teammate) {
@@ -808,8 +1031,8 @@ function failSpawn(name: string, error: string): void {
   }
   deliverToLeader({
     from: name,
-    subject: "Teammate failed to start",
-    body: `Teammate @${name} could not start.\nError: ${error}`,
+    subject: "Agent failed to start",
+    body: `Agent @${name} could not start.\nError: ${error}`,
   });
   publishStateSnapshot();
   notifyChange();
@@ -817,44 +1040,53 @@ function failSpawn(name: string, error: string): void {
 
 // ── Shutdown and close ────────────────────────────────────────────
 
+export async function shutdownTeammateExact(name: string, spawnId: string): Promise<{ ok: true; body: string } | { ok: false; error: string }> {
+  const existing = getTeammate(name);
+  if (!existing || existing.spawnId !== spawnId || existing.status === "stopped") {
+    return { ok: false, error: `No living session named "${exactSessionRoute(name, spawnId)}".` };
+  }
+  return shutdownTeammate(name);
+}
+
 export async function shutdownTeammate(name: string): Promise<{ ok: true; body: string } | { ok: false; error: string }> {
   const teammate = getTeammate(name);
   if (!teammate || teammate.status === "stopped") return { ok: false, error: `No living teammate named "${name}".` };
   pendingShutdowns.add(name);
-  archiveReportsForConsole(archiveQueuedReports(teammate.spawnId));
   const terminated = await terminateTeammate(name);
-  if (!terminated) {
+  if (terminated.outcome === "unconfirmed") {
+    return { ok: false, error: `Agent @${name} could not be confirmed closed; shutdown remains pending.` };
+  }
+  if (terminated.outcome === "missing" && !confirmedStopTimes.has(teammate.spawnId)) {
+    rememberBounded(confirmedStopTimes, teammate.spawnId, Date.now());
     // The child was already gone; synthesize the close bookkeeping.
     pendingShutdowns.delete(name);
-    const released = releaseTasksOf(name, "Teammate was shut down.");
+    const released = releaseTasksOf(name, "Agent was stopped.");
     for (const task of released) {
-      verifyFailures.delete(`${task.id}:${teammate.spawnId}`);
       clearInconclusiveForHolding(task.id, teammate.spawnId);
-      verifyingTasks.delete(task.id);
+      invalidateVerifyGate(task.id);
       rearmTaskNotice(task.id);
     }
     updateTeammate(name, { status: "stopped", activeTool: undefined });
+    pendingDeliveries.delete(name);
     idleNudgesSent.delete(`${name}:${teammate.spawnId}`);
     selfFinalizeAttempts.delete(`${name}:${teammate.spawnId}`);
     // No close event will fire for an already-gone child, so this branch is
     // the only chance to put the shutdown summary on the delivery channel.
     const summary = summarizeShutdown(name, released.length, 0, undefined);
-    deliverToLeader({ from: name, subject: "Teammate shut down", body: summary });
+    deliverToLeader({ from: name, subject: "Agent stopped", body: summary });
     publishStateSnapshot();
     notifyChange();
     return { ok: true, body: summary };
   }
-  // Close finalization completes state transitions and reporting.
-  return {
-    ok: true,
-    body: `Shutdown requested for @${name}.`,
-  };
+  await closeFinalizations.get(teammate.spawnId);
+  return { ok: true, body: `Agent @${name} stopped.` };
 }
 
 async function handleTeammateClose(name: string, spawnId: string, result: WorkerProcessResult): Promise<void> {
   if (!runtimeStateFile) return;
   const teammate = getTeammate(name);
   if (!teammate || teammate.spawnId !== spawnId || teammate.status === "stopped") return;
+  rememberBounded(confirmedStopTimes, spawnId, Date.now());
   const requested = pendingShutdowns.has(name);
   const crashed = !requested && !isCleanExit(result);
 
@@ -864,15 +1096,15 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
   // written before close is lost.
   drainTeammateOutboxes();
 
-  const released = releaseTasksOf(name, requested ? "Teammate was shut down." : "Teammate stopped unexpectedly.");
+  const released = releaseTasksOf(name, requested ? "Agent was stopped." : "Agent stopped unexpectedly.");
   for (const task of released) {
-    verifyFailures.delete(`${task.id}:${teammate.spawnId}`);
     clearInconclusiveForHolding(task.id, teammate.spawnId);
-    verifyingTasks.delete(task.id);
+    invalidateVerifyGate(task.id);
     rearmTaskNotice(task.id);
   }
   pendingShutdowns.delete(name);
   // A stopped teammate must not keep the poll loop or its queue alive.
+  pendingSubmissions.delete(name);
   pendingDeliveries.delete(name);
   idleNudgesSent.delete(`${name}:${teammate.spawnId}`);
   selfFinalizeAttempts.delete(`${name}:${teammate.spawnId}`);
@@ -885,16 +1117,12 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
   removeWorkerOutbox(requireStateFile(), name, teammate.spawnId);
 
   if (requested) {
-    // The close handler drains a final outbox after shutdown was requested.
-    // Archive that spawn again so any report written during termination cannot
-    // become a delayed leader follow-up.
-    archiveReportsForConsole(archiveQueuedReports(spawnId));
     const summary = summarizeShutdown(name, released.length, result.exitCode, result.usage);
-    deliverToLeader({ from: name, subject: "Teammate shut down", body: summary });
+    deliverToLeader({ from: name, subject: "Agent stopped", body: summary });
     // A requested shutdown is already represented by the tool lifecycle row;
     // keep its summary in the console mailbox without starting a leader turn.
   } else {
-    deliverToLeader({ from: name, subject: "Teammate stopped unexpectedly", body: crashDiagnostic(name, result, released) });
+    deliverToLeader({ from: name, subject: "Agent stopped unexpectedly", body: crashDiagnostic(name, result, released) });
     const closeReport = {
       teammate: name,
       spawnId: teammate.spawnId,
@@ -903,7 +1131,6 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
       harnessEvent: { type: "unexpected-stop", subject: `@${name} stopped unexpectedly` },
       finished: false,
     };
-    recordTerminalReport(closeReport);
     sendUpdate(closeReport);
   }
   publishStateSnapshot();
@@ -918,31 +1145,20 @@ function closeErrorText(result: WorkerProcessResult, crashed: boolean): string |
 
 function crashDiagnostic(name: string, result: WorkerProcessResult, released: Array<{ id: string }>): string {
   return [
-    `Teammate @${name} closed without a shutdown request.`,
+    `Agent @${name} closed without a shutdown request.`,
     result.stderr?.trim() ? `stderr: ${result.stderr.trim()}` : undefined,
     released.length > 0 ? `Released claimed task(s): ${released.map((t) => t.id).join(", ")}.` : undefined,
     result.stdout?.trim() ? `Last output: ${result.stdout.trim()}` : undefined,
   ].filter(Boolean).join("\n");
 }
 
-/** Retain reports the follow-up queue suppressed so the teammate detail view
- * can show what was archived without turning it into another leader prompt. */
-function archiveReportsForConsole(reports: FollowUpReport[]): void {
-  for (const report of reports) {
-    if (!report.eventId) continue;
-    const message = getState().leaderMailbox.find((candidate) => candidate.id === report.eventId);
-    if (message) message.archived = true;
-  }
-  if (reports.length > 0) markStateDirty();
-}
-
 function summarizeShutdown(
   name: string,
   releasedCount: number,
   exitCode: number | null | undefined,
   usage?: import("./types").WorkerUsage,
 ): string {
-  const lines = [`Teammate @${name} shut down (exit code ${exitCode ?? "unknown"}).`];
+  const lines = [`Agent @${name} stopped (exit code ${exitCode ?? "unknown"}).`];
   if (releasedCount > 0) lines.push(`Released claimed task(s): ${releasedCount}.`);
   if (usage) lines.push(`Lifetime usage: ${usage.totalTokens} tokens, $${usage.cost.toFixed(4)}.`);
   return lines.join("\n");
@@ -978,8 +1194,8 @@ async function finalizeWorktree(name: string): Promise<void> {
     from: name,
     subject: "Worktree diff captured",
     body: changed
-      ? `Teammate @${name}'s worktree diff:\n\n=== Worktree changes ===\n${captured.diff.diffStat}\n\n${captured.diff.patch}`
-      : `Teammate @${name}'s worktree diff:\n(no worktree changes)`,
+      ? `Agent @${name}'s worktree diff:\n\n=== Worktree changes ===\n${captured.diff.diffStat}\n\n${captured.diff.patch}`
+      : `Agent @${name}'s worktree diff:\n(no worktree changes)`,
   });
   // Changed work must reach the leader even though the worktree directory is
   // gone: dispatch a bounded preview plus the branch retrieval command. A
@@ -1016,33 +1232,31 @@ async function finalizeWorktree(name: string): Promise<void> {
 
 // ── Report outbox draining ────────────────────────────────────────
 
-/** Drain validated report events from every living teammate's outbox. */
-export function drainTeammateOutboxes(): void {
+/** Poll one batch per worker; explicit control drains its recipient's existing snapshot. */
+export function drainTeammateOutboxes(recipient?: string): void {
   const stateFile = requireStateFile();
-  let changed = false;
   for (const teammate of livingTeammates()) {
     const key = `${teammate.name}:${teammate.spawnId}`;
+    const file = workerOutboxPath(stateFile, teammate.name, teammate.spawnId);
+    const endOffset = teammate.name === recipient ? fs.statSync(file, { throwIfNoEntry: false })?.size ?? 0 : undefined;
     const offsets = getState().workerEventOffsets;
-    const previousOffset = offsets[key] ?? 0;
-    const { records, nextOffset, diagnostics } = readJsonlBatch(
-      workerOutboxPath(stateFile, teammate.name, teammate.spawnId),
-      previousOffset,
-    );
-    if (nextOffset !== previousOffset) {
-      offsets[key] = nextOffset;
-      changed = true;
-    }
-    for (const diagnostic of diagnostics) deliverDiagnostic(teammate.name, diagnostic);
-    for (const record of records) {
-      if (applyOutboxRecord(teammate, record)) changed = true;
+    while (true) {
+      const previousOffset = offsets[key] ?? 0;
+      const { records, nextOffset, diagnostics } = readJsonlBatch(file, previousOffset, endOffset);
+      if (nextOffset !== previousOffset) {
+        offsets[key] = nextOffset;
+      }
+      for (const diagnostic of diagnostics) deliverDiagnostic(teammate.name, diagnostic);
+      for (const record of records) {
+        applyOutboxRecord(teammate, record);
+      }
+      if (endOffset === undefined || nextOffset >= endOffset || nextOffset <= previousOffset) break;
     }
   }
-  // Persist on transitions, not per poll tick.
-  if (changed) markStateDirty();
 }
 
 function deliverDiagnostic(from: string, detail: string): void {
-  deliverToLeader({ from, subject: "Teammate channel diagnostic", body: detail });
+  deliverToLeader({ from, subject: "Agent channel diagnostic", body: detail });
 }
 
 function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
@@ -1052,42 +1266,36 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
   const eventKey = `${teammate.spawnId}:${record.id}`;
   if (ids[eventKey]) return false;
   ids[eventKey] = teammate.spawnId;
-  markStateDirty();
 
-  if (teammate.reportSequenceEnded) return false;
+  const reportAssignmentId = teammate.assignment?.id ?? teammate.lastAssignment?.id;
+  if (record.assignmentId !== reportAssignmentId || teammate.reportSequenceEnded) return false;
   const archived = pendingShutdowns.has(teammate.name);
-  const terminal = record.status === "completed" || record.status === "failed";
-  if (terminal) {
-    const assignment = teammate.assignment;
-    if (assignment?.kind === "direct") {
-      assignTeammate(teammate.name, { ...assignment, closed: true }, undefined);
-    }
-    updateTeammate(teammate.name, {
-      reportSequenceEnded: true,
-      status: "idle",
-      activeTool: undefined,
-      sequenceEnded: true,
-    });
-    if (assignment?.kind === "board" && teammate.currentTaskId) {
-      deliverFeedback(
-        teammate.name,
-        "Board task still open",
-        `Your terminal leader report does not complete board task "${teammate.currentTaskId}". Submit it with task_submit, or submit failed to release it.`,
-      );
+  const status = record.status;
+  if (status === "completed" || status === "failed") {
+    const taskId = teammate.currentTaskId;
+    const task = taskId ? getTask(taskId) : undefined;
+    if (teammate.assignment && taskId && task?.claimedBy === teammate.name
+      && (task.status === "claimed" || task.status === "superseded")) {
+      applySubmissionMarker({
+        taskId, worker: teammate.name, spawnId: teammate.spawnId, assignmentId: teammate.assignment.id,
+        status, result: record.body, timestamp: record.timestamp ?? Date.now(),
+      });
+    } else {
+      receiveWorkerMessage(record, { archived: true });
     }
+    return true;
   }
   receiveWorkerMessage({
     id: record.id,
     type: "message",
     worker: teammate.name,
     spawnId: teammate.spawnId,
+    assignmentId: record.assignmentId,
     body: record.body,
     status: record.status,
     timestamp: record.timestamp,
   }, { archived });
-  // Every accepted teammate-authored report reaches the leader's context as
-  // its own turn; terminal statuses additionally end the report sequence.
-  const finished = terminal;
+  // Informational events carry no Work acceptance authority.
   const report = {
     teammate: teammate.name,
     agent: teammate.agent,
@@ -1095,13 +1303,14 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
     body: record.body,
     origin: "teammate" as const,
     eventId: record.id,
+    assignmentId: record.assignmentId,
+    workId: teammate.workId,
     status: record.status,
     timestamp: record.timestamp ?? Date.now(),
-    finished,
+    finished: false,
     ...(archived ? { archived: true } : {}),
   };
-  if (finished) recordTerminalReport(report);
-  sendUpdate(report);
+  if (!archived) sendUpdate(report);
   return true;
 }
 
@@ -1115,6 +1324,7 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
 export function routePeerInboxes(): void {
   const stateFile = requireStateFile();
   for (const teammate of livingTeammates()) {
+    if (pendingShutdowns.has(teammate.name)) continue;
     const inboxName = teammate.name;
     const inbox = inboxPath(stateFile, inboxName);
     const offset = getPeerInboxOffset(inboxName);
@@ -1128,6 +1338,18 @@ export function routePeerInboxes(): void {
       const message = parseInboxMessage(record);
       if (!message || isPeerDelivered(inboxName, message.id)) continue;
       markPeerDelivered(inboxName, message.id);
+      // Mail addressed to an earlier incarnation is not this resident's to read.
+      // Dropping it is recorded once so a replacement never inherits stale
+      // intent, and the sender — never the leader's context — is told.
+      if (message.toSpawnId && message.toSpawnId !== teammate.spawnId) {
+        setPeerDeliveryState(message.id, "dropped");
+        deliverFeedback(
+          message.from,
+          "Message not delivered",
+          `Your message "${message.subject}" was addressed to an earlier incarnation of @${inboxName} that is no longer running, so it was not delivered. Re-resolve the recipient and send it again.`,
+        );
+        continue;
+      }
       dispatchInboxMessage(teammate, message);
     }
   }
@@ -1138,12 +1360,61 @@ function parseInboxMessage(record: unknown): InboxMessage | undefined {
   const candidate = record as Partial<InboxMessage>;
   if (typeof candidate.id !== "string" || typeof candidate.from !== "string") return undefined;
   if (typeof candidate.subject !== "string" || typeof candidate.body !== "string") return undefined;
+  if (candidate.toSpawnId !== undefined && typeof candidate.toSpawnId !== "string") return undefined;
   return { ...candidate, timestamp: candidate.timestamp ?? Date.now() } as InboxMessage;
 }
 
+function submissionPending(teammate: Teammate): boolean {
+  const pending = pendingSubmissions.get(teammate.name);
+  if (pending?.spawnId === teammate.spawnId && pending.assignmentId === teammate.assignment?.id) return true;
+  const task = teammate.currentTaskId ? getState().tasks[teammate.currentTaskId] : undefined;
+  return teammate.assignment?.kind === "direct" && teammate.assignment.closed === true
+    && task?.status === "claimed" && task.claimedBy === teammate.name;
+}
+
+function gateInFlight(teammate: Teammate): boolean {
+  return teammate.currentTaskId !== undefined && verifyingTasks.has(teammate.currentTaskId);
+}
+
+function verificationFrozen(teammate: Teammate): boolean {
+  const taskId = teammate.currentTaskId;
+  if (!taskId) return false;
+  const holding = `${taskId}:${teammate.spawnId}`;
+  return submissionPending(teammate) || gateInFlight(teammate) || verifyFailureParks.has(holding) || unexpectedExecutionParks.has(holding) || inconclusiveParks.has(holding);
+}
+
+function archiveDeferredDeliveries(teammate: Teammate): void {
+  const deliveries = pendingDeliveries.get(teammate.name) ?? [];
+  if (deliveries.length === 0) return;
+  pendingDeliveries.delete(teammate.name);
+  const task = teammate.currentTaskId ? getState().tasks[teammate.currentTaskId] : undefined;
+  if (task) {
+    task.deferredMessages = [
+      ...(task.deferredMessages ?? []),
+      ...deliveries.map(({ from, subject, body, timestamp }) => ({ from, subject, body, timestamp })),
+    ].slice(-20);
+    task.updatedAt = Date.now();
+  }
+  for (const delivery of deliveries) setPeerDeliveryState(delivery.id, "routed");
+  markBoardChanged();
+}
+
 function dispatchInboxMessage(teammate: Teammate, message: InboxMessage): void {
-  const routed = teammate.status === "working"
-    ? sendWorkerSteer(teammate.name, formatDelivery([message]))
+  if (verificationFrozen(teammate)) {
+    setPeerDeliveryState(message.id, "queued");
+    const queued = pendingDeliveries.get(teammate.name) ?? [];
+    queued.push(message);
+    pendingDeliveries.set(teammate.name, queued);
+    ensureLivePoll();
+    return;
+  }
+  const marker = teammate.assignment ? `[agent-teams-assignment:${teammate.assignment.id}]\n` : "";
+  const routed = !teammate.reportSequenceEnded && (
+    teammate.status === "working"
+    || teammate.status === "starting"
+    || isFreshAssignmentPending(teammate.name)
+  )
+    ? sendWorkerFollowUp(teammate.name, `${marker}${formatDelivery([message])}`)
     : false;
   if (routed) {
     setPeerDeliveryState(message.id, "routed");
@@ -1156,7 +1427,7 @@ function dispatchInboxMessage(teammate: Teammate, message: InboxMessage): void {
   ensureLivePoll();
 }
 
-/** Route the leader's addressed send_message through the same delivery path. */
+/** Route the leader's addressed agent_event through the same delivery path. */
 export type MessageRoutingOutcome = "steered" | "queued";
 
 export type SendLeaderMessageResult =
@@ -1168,23 +1439,146 @@ export type SendLeaderMessageResult =
  * mailbox entry carries terminal status. Lets the leader read the report
  * directly instead of steering the teammate into a duplicate resend. */
 function recordedTerminalReportBody(name: string): string | undefined {
+  const teammate = getTeammate(name);
+  const assignmentId = teammate?.assignment?.id ?? teammate?.lastAssignment?.id;
   const mailbox = getState().leaderMailbox;
   for (let i = mailbox.length - 1; i >= 0; i--) {
     const message = mailbox[i];
-    if (message.from !== name) continue;
-    return message.status === "completed" || message.status === "failed" ? message.body : undefined;
+    if (message.archived || message.from !== name || message.assignmentId !== assignmentId || message.spawnId !== teammate?.spawnId) continue;
+    if (message.status === "completed" || message.status === "failed") return message.body;
   }
-  return undefined;
+  const taskId = teammate?.lastTaskId;
+  const task = taskId ? getTask(taskId) : undefined;
+  return task?.status === "completed" ? task.result : undefined;
+}
+
+export type AssignExistingWorkResult =
+  | { ok: true; workId: string; owner: string; assignmentId: string }
+  | { ok: false; error: string };
+
+/** Assign one pending Work Item to an exact idle resident through a fresh Pi
+ * session. The record is claimed before reset; reset failure releases it. */
+export function assignExistingWork(workId: string, session: string): AssignExistingWorkResult {
+  const teammate = resolveExactSession(session, listTeammates());
+  if (!teammate) return { ok: false, error: "Work assignment requires a current exact session route." };
+  const owner = teammate.name;
+  const task = getState().tasks[workId];
+  if (!teammate || teammate.status === "stopped") return { ok: false, error: `No living teammate named "${owner}".` };
+  if (task?.status === "claimed" && task.claimedBy === owner
+    && teammate.currentTaskId === workId && teammate.assignment && !teammate.assignment.closed) {
+    return { ok: true, workId, owner, assignmentId: teammate.assignment.id };
+  }
+  if (teammate.status !== "idle" || teammate.assignment || isFreshAssignmentPending(owner)) {
+    return { ok: false, error: `@${owner} is not an idle session available for Work assignment.` };
+  }
+  if (!task || task.status !== "pending") return { ok: false, error: `Work Item "${workId}" is not pending.` };
+  if (!taskDependenciesMet(task)) return { ok: false, error: `Work Item "${workId}" has unmet dependencies.` };
+  if (activeAssignmentConflict(task.resources, owner)) return { ok: false, error: `Work Item "${workId}" conflicts with active Work resources.` };
+  const assignment = { id: `direct:${randomUUID()}`, kind: "direct" as const, resources: task.resources };
+  const claimed = reclaimDirectWork(workId, owner, assignment, "pending");
+  if (!claimed.ok) return claimed;
+  updateTeammate(owner, { reportSequenceEnded: false });
+  flushSnapshots();
+  const prompt = buildFreshAssignmentPrompt(teammate, assignment.id, [
+    `Work Item ${task.id}: ${task.subject}`,
+    task.description,
+    "Complete this assignment and return the result as your final answer.",
+  ].filter(Boolean).join("\n\n"));
+  void deliverFreshAssignment(owner, prompt).then((sent) => {
+    if (sent) {
+      updateTeammate(owner, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
+      return;
+    }
+    if (getTeammate(owner)?.assignment?.id === assignment.id) {
+      releaseTask(workId, "Pi session reset failed before the assigned Work started.");
+    }
+    deliverDiagnostic(owner, "Pi session reset failed; the assigned Work was not delivered.");
+  });
+  return { ok: true, workId, owner, assignmentId: assignment.id };
+}
+
+export type ReopenExistingWorkResult =
+  | { ok: true; workId: string; subject: string; resources: string[] }
+  | { ok: false; error: string };
+
+/** Reopen only a completed Work Item. Active, parked, superseded, and released
+ * states remain governed by their explicit lifecycle transitions. */
+export function reopenExistingWork(workId: string): ReopenExistingWorkResult {
+  const reopened = reopenCompletedWork(workId);
+  if (!reopened.ok) return reopened;
+  publishStateSnapshot();
+  ensureLivePoll();
+  notifyChange();
+  return { ok: true, workId: reopened.task.id, subject: reopened.task.subject, resources: reopened.task.resources };
+}
+
+export type ReleaseExistingWorkResult =
+  | { ok: true; workId: string; subject: string; resources: string[]; holderStillRunning?: string }
+  | { ok: false; error: string };
+
+/** Return one claimed Work Item to pending. This invalidates all in-memory
+ * submission/review authority before the single-writer state release. */
+export function releaseExistingWork(workId: string, reason: string): ReleaseExistingWorkResult {
+  const task = getState().tasks[workId];
+  if (!task || task.status !== "claimed") return { ok: false, error: `Work Item "${workId}" is not claimed.` };
+  const holder = task.claimedBy ? getTeammate(task.claimedBy) : undefined;
+  let holderStillRunning: string | undefined;
+  if (holder) {
+    pendingSubmissions.delete(holder.name);
+    invalidateVerifyGate(workId);
+    clearInconclusiveForHolding(workId, holder.spawnId);
+    archiveDeferredDeliveries(holder);
+    sendWorkerSteer(holder.name, `Work Item "${workId}" was released by the leader: ${reason}. Stop work on this assignment.`);
+    deliverFeedback(holder.name, `Work Item "${workId}" released`, `Work Item "${workId}" was released by the leader: ${reason}.`);
+    // Release frees the resource immediately by contract. When the holder is
+    // still working, its in-flight tool batch may still be writing, so the
+    // residual window is reported instead of being silently implied safe.
+    holderStillRunning = holder.status === "working" ? holder.name : undefined;
+  }
+  const released = releaseTask(workId, reason);
+  if (!released) return { ok: false, error: `Work Item "${workId}" could not be released.` };
+  rearmTaskNotice(workId);
+  publishStateSnapshot();
+  ensureLivePoll();
+  notifyChange();
+  return { ok: true, workId: released.id, subject: released.subject, resources: released.resources, ...(holderStillRunning ? { holderStillRunning } : {}) };
 }
 
 export function sendLeaderMessage(
   to: string,
   message: string,
-  options?: { reopen?: boolean; resources?: string[] },
+  options?: { reopen?: boolean | "if-closed"; resources?: string[]; workId?: string },
 ): SendLeaderMessageResult {
+  drainTeammateOutboxes(to);
   const teammate = getTeammate(to);
   if (!teammate || teammate.status === "stopped") return { ok: false, error: `No living teammate named "${to}".` };
-  if (teammate.assignment?.kind === "direct" && teammate.assignment.closed && !options?.reopen) {
+  if (pendingShutdowns.has(to)) return { ok: false, error: `Agent @${to} is stopping; new work is not accepted.` };
+  // Explicit work control chooses after draining, not from a stale caller snapshot.
+  const selectedWorkId = options?.workId ?? teammate.workId;
+  const unexpectedParkKey = selectedWorkId ? `${selectedWorkId}:${teammate.spawnId}` : undefined;
+  const recoveringUnexpectedExecution = options?.reopen === true && unexpectedParkKey !== undefined
+    && unexpectedExecutionParks.has(unexpectedParkKey);
+  if (verificationFrozen(teammate) && !recoveringUnexpectedExecution) {
+    const envelope: InboxMessage = {
+      id: randomUUID(), from: "leader", subject: messageTitle(message), body: message, timestamp: Date.now(), toSpawnId: teammate.spawnId,
+    };
+    const queued = pendingDeliveries.get(teammate.name) ?? [];
+    queued.unshift(envelope);
+    pendingDeliveries.set(teammate.name, queued);
+    ensureLivePoll();
+    return { ok: true, outcome: "queued" };
+  }
+  const selectedExistingWork = selectedWorkId ? getState().tasks[selectedWorkId] : undefined;
+  const reopen = options?.reopen === "if-closed"
+    ? teammate.assignment?.closed === true || selectedExistingWork?.status === "completed"
+    : options?.reopen;
+  if (options?.reopen === undefined && (!teammate.assignment || teammate.assignment.closed)) {
+    const prior = recordedTerminalReportBody(to);
+    if (prior) return { ok: true, outcome: "not-sent", terminalReport: prior };
+    return { ok: false, error: `@${to} has no open assignment. Use work action=assign for pending Work, or work action=reopen then assign for completed Work.` };
+  }
+  const retryReleasedWork = selectedExistingWork?.status === "pending" && teammate.assignment === undefined;
+  if (teammate.assignment?.kind === "direct" && teammate.assignment.closed && !reopen && !retryReleasedWork) {
     const prior = recordedTerminalReportBody(to);
     if (prior) return { ok: true, outcome: "not-sent", terminalReport: prior };
     return { ok: false, error: `@${to} has a closed direct assignment. Use reopen=true for an explicit next assignment.` };
@@ -1193,31 +1587,63 @@ export function sendLeaderMessage(
   // able to steer it for verify feedback or an inconclusive decision without
   // replacing its assignment.
   const activeBoardHolder = teammate.assignment?.kind === "board" && !teammate.assignment.closed;
-  if (teammate.reportSequenceEnded && !options?.reopen && !activeBoardHolder) {
+  if (teammate.reportSequenceEnded && !reopen && !retryReleasedWork && !activeBoardHolder) {
     const prior = recordedTerminalReportBody(to);
     if (prior) return { ok: true, outcome: "not-sent", terminalReport: prior };
-    return { ok: false, error: `@${to} already sent a terminal report. Use teammate_spawn for a new assignment or send_message with reopen=true for an explicit follow-up assignment.` };
+    return { ok: false, error: `@${to} already sent a terminal report. Use work action=reopen followed by work action=assign for another Work attempt.` };
   }
   const priorTerminalReport = teammate.reportSequenceEnded ? recordedTerminalReportBody(to) : undefined;
   const boardParkKey = teammate.currentTaskId ? `${teammate.currentTaskId}:${teammate.spawnId}` : undefined;
-  if (options?.reopen && teammate.assignment && !teammate.assignment.closed) {
+  if ((reopen || retryReleasedWork) && selectedWorkId && verifyingTasks.has(selectedWorkId)) {
+    return { ok: false, error: `Work Item "${selectedWorkId}" is awaiting verification; wait for the gate outcome before reopening.` };
+  }
+  if (reopen && teammate.assignment && !teammate.assignment.closed && !recoveringUnexpectedExecution) {
     const action = teammate.assignment.kind === "board"
-      ? `task_submit or be released/superseded`
+      ? `work action=submit or be released/superseded`
       : "send a terminal report or be explicitly released";
     return { ok: false, error: `@${to} still owns active ${teammate.assignment.kind} assignment "${teammate.assignment.id}". It must ${action} before a direct assignment can open.` };
   }
-  const opensDirectAssignment = options?.reopen || teammate.assignment === undefined;
+  const opensDirectAssignment = reopen || retryReleasedWork || teammate.assignment === undefined;
   if (opensDirectAssignment) {
-    const resources = normalizeResources(options?.resources);
-    const conflict = activeAssignmentConflict(resources, to);
-    if (conflict) {
-      return { ok: false, error: `Direct assignment resources conflict with @${conflict.name}'s ${conflict.assignment?.kind} assignment "${conflict.assignment?.id}".` };
-    }
-    assignTeammate(to, {
+    const existingWork = getState().tasks[selectedWorkId ?? ""];
+    const reclaimingExistingWork = (reopen && (existingWork?.status === "completed" || recoveringUnexpectedExecution)) || retryReleasedWork;
+    const resources = reclaimingExistingWork
+      ? existingWork.resources
+      : normalizeResources(options?.resources);
+    const assignment = {
       id: `direct:${randomUUID()}`,
-      kind: "direct",
+      kind: "direct" as const,
       resources,
-    }, undefined);
+    };
+    if (reclaimingExistingWork) {
+      const reclaimed = reclaimDirectWork(
+        selectedWorkId ?? "",
+        to,
+        assignment,
+        retryReleasedWork ? "pending" : recoveringUnexpectedExecution ? "claimed" : "completed",
+        recoveringUnexpectedExecution,
+      );
+      if (!reclaimed.ok) return reclaimed;
+    } else {
+      const conflict = activeAssignmentConflict(resources, to);
+      if (conflict) {
+        return { ok: false, error: `Direct assignment resources conflict with @${conflict.name}'s ${conflict.assignment?.kind} assignment "${conflict.assignment?.id}".` };
+      }
+      if (selectedWorkId) {
+        const created = createDirectWork({
+          id: selectedWorkId,
+          subject: messageTitle(message),
+          description: message,
+          resources,
+          workerName: to,
+          assignment,
+        });
+        if (!created.ok) return created;
+        updateTeammate(to, { workId: selectedWorkId });
+      } else {
+        assignTeammate(to, assignment, undefined);
+      }
+    }
     updateTeammate(to, { reportSequenceEnded: false });
   }
   // A successfully accepted leader message is the explicit direction that
@@ -1225,19 +1651,40 @@ export function sendLeaderMessage(
   if (boardParkKey) {
     inconclusiveParks.delete(boardParkKey);
     verifyFailureParks.delete(boardParkKey);
+    unexpectedExecutionParks.delete(boardParkKey);
   }
   if (activeBoardHolder) updateTeammate(to, { reportSequenceEnded: false });
   const envelope: InboxMessage = {
     id: randomUUID(),
     from: "leader",
     subject: messageTitle(message),
-    body: message,
+    body: `${opensDirectAssignment || (activeBoardHolder && priorTerminalReport !== undefined) ? `[agent-teams-assignment:${teammate.assignment?.id ?? "none"}]\n` : ""}${message}`,
     timestamp: Date.now(),
+    toSpawnId: teammate.spawnId,
   };
-  const steered = teammate.status === "working" && sendWorkerSteer(teammate.name, formatDelivery([envelope]));
+  flushSnapshots();
+  if (opensDirectAssignment) {
+    void deliverFreshAssignment(teammate.name, formatDelivery([envelope])).then((sent) => {
+      if (sent) {
+        updateTeammate(to, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
+        return;
+      }
+      const current = getTeammate(to);
+      const currentTaskId = current?.currentTaskId;
+      if (current?.assignment?.id === teammate.assignment?.id && currentTaskId) {
+        releaseTask(currentTaskId, "Pi session reset failed before the new Assignment Attempt started.");
+      } else if (current?.assignment?.id === teammate.assignment?.id) {
+        assignTeammate(to, undefined, undefined);
+      }
+      deliverDiagnostic(to, "Pi session reset failed; the new Assignment Attempt was not delivered.");
+    });
+    return { ok: true, outcome: "queued", ...(priorTerminalReport ? { priorTerminalReport } : {}) };
+  }
+  const steered = sendWorkerSteer(teammate.name, formatDelivery([envelope]));
+  if (steered) updateTeammate(to, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
   if (steered) return { ok: true, outcome: "steered", ...(priorTerminalReport ? { priorTerminalReport } : {}) };
   const queued = pendingDeliveries.get(teammate.name) ?? [];
-  queued.push(envelope);
+  queued.unshift(envelope);
   pendingDeliveries.set(teammate.name, queued);
   ensureLivePoll();
   return { ok: true, outcome: "queued", ...(priorTerminalReport ? { priorTerminalReport } : {}) };
@@ -1251,8 +1698,15 @@ function continueMaybeCompact(inbox: string, inboxName: string, offset: number):
     return;
   }
   // Truncate only fully-consumed inboxes; message ids make replay safe.
+  // Rotation, not truncation: a teammate appending concurrently would lose its
+  // message inside the stat/truncate window, while a rename always preserves
+  // the records on disk and lets the next append start a fresh file.
   if (size > INBOX_COMPACT_BYTES && offset >= size) {
-    fs.truncateSync(inbox, 0);
+    try {
+      fs.renameSync(inbox, `${inbox}.compacted-${Date.now()}`);
+    } catch {
+      return;
+    }
     setPeerInboxOffset(inboxName, 0);
   }
 }
@@ -1294,19 +1748,30 @@ export function processTaskIntents(): void {
 
 function applyClaimMarker(intent: import("./types").TaskIntent): void {
   const sender = findLivingTeammate(intent);
-  if (!sender) return;
+  if (!sender || pendingShutdowns.has(sender.name)) return;
   const outcome = applyClaimIntent(intent);
   if (outcome.applied) {
-    verifyFailures.delete(`${intent.taskId}:${intent.spawnId}`);
     clearInconclusiveForHolding(intent.taskId, intent.spawnId);
     // A new holding must not inherit an in-flight gate from a previous one.
-    verifyingTasks.delete(intent.taskId);
+    invalidateVerifyGate(intent.taskId);
     updateTeammate(intent.worker, { currentTaskId: intent.taskId });
-    deliverFeedback(
-      intent.worker,
-      "Claim accepted",
-      `Your claim for task "${intent.taskId}" was accepted. You now own the board assignment and may start work; complete it with task_submit.`,
-    );
+    const teammate = getTeammate(intent.worker);
+    const task = getState().tasks[intent.taskId];
+    if (!teammate?.assignment || !task) return;
+    const kickoff = [
+      `Claim accepted for Work Item ${task.id}: ${task.subject}`,
+      task.description,
+      "Complete this assignment with work action=submit.",
+    ].filter(Boolean).join("\n\n");
+    const assignmentId = teammate.assignment.id;
+    flushSnapshots();
+    void deliverFreshAssignment(teammate.name, buildFreshAssignmentPrompt(teammate, assignmentId, kickoff)).then((sent) => {
+      if (sent) return;
+      if (getTeammate(teammate.name)?.assignment?.id === assignmentId) {
+        releaseTask(task.id, "Pi session reset failed before the claimed Assignment Attempt started.");
+      }
+      deliverDiagnostic(teammate.name, "Pi session reset failed; the claimed Assignment Attempt was not delivered.");
+    });
     return;
   }
   deliverFeedback(intent.worker, "Claim rejected", outcome.reason ?? "The task is no longer available.");
@@ -1318,8 +1783,10 @@ function applySubmissionMarker(intent: import("./types").TaskIntent): void {
     return;
   }
   const sender = findLivingTeammate(intent);
-  if (!sender) return;
+  if (!sender || !sender.assignment || intent.assignmentId !== sender.assignment.id) return;
   const task = getState().tasks[intent.taskId];
+  const pending = pendingSubmissions.get(intent.worker);
+  if (pending?.spawnId === intent.spawnId && pending.assignmentId === intent.assignmentId) return;
   if (!task || (task.status !== "claimed" && task.status !== "superseded") || task.claimedBy !== intent.worker) {
     deliverFeedback(intent.worker, "Submission rejected", `Task "${intent.taskId}" is not currently yours.`);
     return;
@@ -1329,20 +1796,24 @@ function applySubmissionMarker(intent: import("./types").TaskIntent): void {
       deliverFeedback(intent.worker, "Submission rejected", `Task "${intent.taskId}" was superseded by "${task.supersededBy ?? "a replacement"}". Stop work and submit failed to acknowledge cancellation.`);
       return;
     }
-    releaseTask(intent.taskId, intent.result?.trim() || "Superseded task cancellation acknowledged.");
-    clearInconclusiveForHolding(intent.taskId, intent.spawnId);
-    verifyingTasks.delete(intent.taskId);
+    if (sender.sequenceEnded === false) {
+      pendingSubmissions.set(intent.worker, { ...intent, assignmentId: sender.assignment.id, verify: undefined });
+    } else {
+      releaseSupersededHolding(intent);
+    }
     return;
   }
   const parkKey = `${intent.taskId}:${intent.spawnId}`;
-  if (intent.status === "completed" && (inconclusiveParks.has(parkKey) || verifyFailureParks.has(parkKey))) {
-    const reason = inconclusiveParks.has(parkKey)
-      ? "two inconclusive reviews"
-      : "two explicit verification failures";
+  if (intent.status === "completed" && (inconclusiveParks.has(parkKey) || verifyFailureParks.has(parkKey) || unexpectedExecutionParks.has(parkKey))) {
+    const reason = unexpectedExecutionParks.has(parkKey)
+      ? "unexpected execution during verification"
+      : inconclusiveParks.has(parkKey)
+        ? "two inconclusive reviews"
+        : "two explicit verification failures";
     deliverFeedback(
       intent.worker,
       "Submission rejected while verification is parked",
-      `Task "${intent.taskId}" has ${reason}. Wait for an explicit leader steer before submitting another completed outcome.`,
+      `Task "${intent.taskId}" has ${reason}. Wait for explicit Work release and reassignment before submitting another completed outcome.`,
     );
     return;
   }
@@ -1354,17 +1825,11 @@ function applySubmissionMarker(intent: import("./types").TaskIntent): void {
     );
     return;
   }
-  if (intent.status === "failed") {
-    releaseTask(intent.taskId, intent.result?.trim() || "Teammate reported failure.");
-    verifyFailures.delete(`${intent.taskId}:${intent.spawnId}`);
-    clearInconclusiveForHolding(intent.taskId, intent.spawnId);
-    verifyingTasks.delete(intent.taskId);
-    rearmTaskNotice(intent.taskId);
-    freeTeammateFromTask(intent.worker, intent.taskId);
-    notifyTaskOutcome(task.subject, `${intent.worker} reported failure`, intent.result ?? "");
-    return;
-  }
-  beginVerifyOrComplete(intent, task.verify ?? resolveAgent(sender.agent, leaderCwd)?.verify);
+  const verify = intent.status === "completed" ? task.verify ?? resolveAgent(sender.agent, leaderCwd)?.verify : undefined;
+  const assignmentId = sender.assignment?.id;
+  if (!assignmentId) return;
+  if (sender.sequenceEnded === false) pendingSubmissions.set(intent.worker, { ...intent, assignmentId, verify });
+  else beginVerifyOrComplete(intent, verify);
 }
 
 /** Fold one more verify failure into bookkeeping. The first failure invites a
@@ -1378,11 +1843,52 @@ export function reactToVerifyFailure(
   return { count, escalated, escalateToLeader: escalated && previous?.escalated !== true };
 }
 
+function authorizeDirectRevision(intent: import("./types").TaskIntent, detail: string): boolean {
+  const teammate = getTeammate(intent.worker);
+  const task = getState().tasks[intent.taskId];
+  if (!teammate || teammate.spawnId !== intent.spawnId || teammate.assignment?.kind !== "direct" || !task) return false;
+  const assignment = {
+    id: `direct:${randomUUID()}`,
+    kind: "direct" as const,
+    resources: task.resources,
+  };
+  assignTeammate(intent.worker, assignment, intent.taskId);
+  updateTeammate(intent.worker, { reportSequenceEnded: false });
+  flushSnapshots();
+  const revisionBrief = [
+    `The completion gate failed for Work Item ${intent.taskId}: ${task.subject}. Revise the result and return a new final answer.`,
+    task.description,
+    task.verify ? `Verification criteria:\n${task.verify}` : undefined,
+    `Review failure detail:\n${detail}`,
+  ].filter(Boolean).join("\n\n");
+  const prompt = buildFreshAssignmentPrompt(
+    teammate,
+    assignment.id,
+    revisionBrief,
+  );
+  void deliverFreshAssignment(teammate.name, prompt).then((sent) => {
+    if (sent) return;
+    if (getTeammate(teammate.name)?.assignment?.id === assignment.id) {
+      releaseTask(intent.taskId, "Pi session reset failed before the verification revision started.");
+    }
+    deliverDiagnostic(teammate.name, "Pi session reset failed; the verification revision was not delivered.");
+  });
+  return true;
+}
+
 function beginVerifyOrComplete(intent: import("./types").TaskIntent, verify: string | undefined): void {
   const task = getState().tasks[intent.taskId];
   if (!task) return;
+  if (task.status === "superseded") {
+    if (intent.status === "failed") releaseSupersededHolding(intent);
+    return;
+  }
+  if (intent.status === "failed") {
+    finishFailure(intent);
+    return;
+  }
   if (!verify?.trim()) {
-    finishCompletion(intent, task.subject);
+    finishCompletion(intent);
     return;
   }
   // The gate is bound to this exact submission via a unique token: a
@@ -1390,22 +1896,16 @@ function beginVerifyOrComplete(intent: import("./types").TaskIntent, verify: str
   // must not let the stale result complete the new holding.
   const submissionId = `${intent.taskId}:${intent.spawnId}:${randomUUID()}`;
   const token = randomUUID();
-  verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, submissionId, token });
+  const assignmentId = getTeammate(intent.worker)?.assignment?.id;
+  if (!assignmentId) return;
+  verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, assignmentId, submissionId, token });
   const input: VerifyReviewInput = {
     verify,
     taskSubject: task.subject,
     workerResult: intent.result ?? "",
     cwd: getTeammate(intent.worker)?.cwd || leaderCwd,
   };
-  // A reviewer crash is a concrete failed gate. A missing verdict is handled
-  // separately as inconclusive so prose-format drift cannot count as a defect.
-  Promise.resolve()
-    .then(() => verifyGateRunner(input))
-    .then((outcome) => resolveGateOutcome(intent, task.subject, submissionId, token, outcome))
-    .catch((error) => resolveGateOutcome(intent, task.subject, submissionId, token, {
-      kind: "fail",
-      detail: truncated(`(completion review crashed) ${error instanceof Error ? error.message : String(error)}`),
-    }));
+  runVerifyGate(intent, task.subject, submissionId, token, input);
 }
 
 /** Apply one gate outcome to its submission, guarded by the binding token. */
@@ -1419,14 +1919,20 @@ function resolveGateOutcome(
   const active = verifyingTasks.get(intent.taskId);
   if (active?.token !== token || active.submissionId !== submissionId) return;
   verifyingTasks.delete(intent.taskId);
+  const registered = verifyAborts.get(intent.taskId);
+  if (registered?.submissionId === submissionId) verifyAborts.delete(intent.taskId);
   const current = getState().tasks[intent.taskId];
+  const holder = getTeammate(intent.worker);
   const stillHolds = current?.status === "claimed"
     && current.claimedBy === intent.worker
-    && getTeammate(intent.worker)?.spawnId === intent.spawnId;
+    && holder?.spawnId === intent.spawnId
+    && holder.assignment?.id === active.assignmentId
+    && !pendingShutdowns.has(intent.worker);
   if (!stillHolds) return;
   if (outcome.kind === "pass") {
     inconclusiveVerifications.delete(submissionId);
-    finishCompletion(intent, subject);
+    archiveDeferredDeliveries(holder);
+    finishCompletion(intent);
   } else if (outcome.kind === "inconclusive") {
     const detail = outcome.detail ?? "(reviewer omitted a machine-readable verdict)";
     requestVerifyVerdict(intent, subject, submissionId, detail);
@@ -1458,11 +1964,18 @@ function resolveGateOutcome(
         [`The completion gate for "${subject}" failed again (${reaction.count} consecutive failures).`, detail, "The task stays claimed by you. Do not resubmit or reclaim it; the leader has been notified and will decide next steps."].join("\n"),
       );
     } else {
-      deliverFeedback(
-        intent.worker,
-        `Verify failed for ${intent.taskId}`,
-        [`The completion gate for "${subject}" failed.`, detail, "Fix the issues and resubmit with task_submit."].join("\n"),
-      );
+      const directRevision = authorizeDirectRevision(intent, detail);
+      if (!directRevision) {
+        deliverFeedback(
+          intent.worker,
+          `Verify failed for ${intent.taskId}`,
+          [
+            `The completion gate for "${subject}" failed.`,
+            detail,
+            "Fix the issues and resubmit with work action=submit.",
+          ].join("\n"),
+        );
+      }
       notifyTaskOutcome(subject, `verify gate failed for ${intent.taskId}`, detail);
     }
   }
@@ -1482,20 +1995,16 @@ function requestVerifyVerdict(
     const task = getState().tasks[intent.taskId];
     if (!task) return;
     const token = randomUUID();
-    verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, submissionId, token });
+    const assignmentId = getTeammate(intent.worker)?.assignment?.id;
+    if (!assignmentId) return;
+    verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, assignmentId, submissionId, token });
     const input: VerifyReviewInput = {
       verify: `${task.verify ?? resolveAgent(getTeammate(intent.worker)?.agent ?? "", leaderCwd)?.verify ?? ""}\n\nThe previous review was inconclusive:\n${detail}\n\nReply with exactly one line: ${VERIFY_VERDICT_PASS} or ${VERIFY_VERDICT_FAIL} - <reasons>.`,
       taskSubject: task.subject,
       workerResult: intent.result ?? "",
       cwd: getTeammate(intent.worker)?.cwd || leaderCwd,
     };
-    Promise.resolve()
-      .then(() => verifyGateRunner(input))
-      .then((outcome) => resolveGateOutcome(intent, subject, submissionId, token, outcome))
-      .catch((error) => resolveGateOutcome(intent, subject, submissionId, token, {
-        kind: "fail",
-        detail: truncated(`(verdict clarification crashed) ${error instanceof Error ? error.message : String(error)}`),
-      }));
+    runVerifyGate(intent, subject, submissionId, token, input);
     return;
   }
   inconclusiveParks.set(`${intent.taskId}:${intent.spawnId}`, { worker: intent.worker, spawnId: intent.spawnId });
@@ -1503,7 +2012,7 @@ function requestVerifyVerdict(
   deliverFeedback(
     intent.worker,
     `Verification inconclusive for ${intent.taskId}`,
-    `The reviewer twice omitted a machine-readable verdict. Your task remains claimed without a verify failure. Wait for leader direction; after a directed fix or clarified outcome, you may submit a new completed result for a fresh review.\n\n${detail}`,
+    `The reviewer twice omitted a machine-readable verdict. Your task remains claimed without a verify failure. Wait for explicit Work release and reassignment; ordinary messages do not authorize another submission.\n\n${detail}`,
   );
   sendUpdate({
     teammate: "task-board",
@@ -1514,24 +2023,77 @@ function requestVerifyVerdict(
   });
 }
 
+/** Drop every per-holding gate record for one task incarnation. Every authority
+ *  invalidation routes through here so no counter or park outlives the holding
+ *  it was created for. */
 function clearInconclusiveForHolding(taskId: string, spawnId: string): void {
   const prefix = `${taskId}:${spawnId}:`;
   for (const key of inconclusiveVerifications.keys()) {
     if (key.startsWith(prefix)) inconclusiveVerifications.delete(key);
   }
-  inconclusiveParks.delete(`${taskId}:${spawnId}`);
-  verifyFailureParks.delete(`${taskId}:${spawnId}`);
+  const holding = `${taskId}:${spawnId}`;
+  inconclusiveParks.delete(holding);
+  verifyFailureParks.delete(holding);
+  unexpectedExecutionParks.delete(holding);
+  verifyFailures.delete(holding);
 }
 
-function finishCompletion(intent: import("./types").TaskIntent, subject: string): void {
+function finishCompletion(intent: import("./types").TaskIntent): void {
   const task = getState().tasks[intent.taskId];
   if (!task) return;
+  const teammate = getTeammate(intent.worker);
+  const assignmentId = teammate?.assignment?.id;
+  if (!teammate || !assignmentId) return;
+  retirePendingSubmission(intent);
   const completed = completeTask(intent.taskId, intent.result);
   if (!completed) return;
-  verifyFailures.delete(`${intent.taskId}:${intent.spawnId}`);
   clearInconclusiveForHolding(intent.taskId, intent.spawnId);
   freeTeammateFromTask(intent.worker, intent.taskId);
-  notifyTaskOutcome(subject, `${intent.worker} completed`, intent.result ?? "");
+  announceWorkOutcome(intent, teammate, assignmentId);
+}
+
+function retirePendingSubmission(intent: import("./types").TaskIntent): void {
+  const pending = pendingSubmissions.get(intent.worker);
+  if (pending?.spawnId === intent.spawnId && pending.assignmentId === intent.assignmentId) {
+    pendingSubmissions.delete(intent.worker);
+  }
+}
+
+function releaseSupersededHolding(intent: import("./types").TaskIntent): void {
+  retirePendingSubmission(intent);
+  releaseTask(intent.taskId, intent.result?.trim() || "Superseded task cancellation acknowledged.");
+  clearInconclusiveForHolding(intent.taskId, intent.spawnId);
+  invalidateVerifyGate(intent.taskId);
+}
+
+function finishFailure(intent: import("./types").TaskIntent): void {
+  const teammate = getTeammate(intent.worker);
+  const assignmentId = teammate?.assignment?.id;
+  if (!teammate || !assignmentId) return;
+  retirePendingSubmission(intent);
+  const released = releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.");
+  if (!released) return;
+  clearInconclusiveForHolding(intent.taskId, intent.spawnId);
+  invalidateVerifyGate(intent.taskId);
+  rearmTaskNotice(intent.taskId);
+  announceWorkOutcome(intent, teammate, assignmentId);
+}
+
+function announceWorkOutcome(intent: import("./types").TaskIntent, teammate: Teammate, assignmentId: string): void {
+  updateTeammate(intent.worker, { reportSequenceEnded: true });
+  const eventId = randomUUID();
+  const status = intent.status === "failed" ? "failed" : "completed";
+  const report: LeaderReport = {
+    teammate: intent.worker, agent: teammate.agent, spawnId: intent.spawnId,
+    workId: intent.taskId, assignmentId, status, finished: true,
+    origin: "teammate", eventId, timestamp: intent.timestamp,
+    body: intent.result || "(no result summary submitted)",
+  };
+  receiveWorkerMessage({
+    id: eventId, type: "message", worker: intent.worker, spawnId: intent.spawnId,
+    assignmentId, status, body: report.body, timestamp: report.timestamp,
+  });
+  sendUpdate(report);
 }
 
 // ── Verify gate: fresh one-shot reviewer with a VERDICT protocol ──
@@ -1550,6 +2112,10 @@ export interface VerifyReviewInput {
   /** Working directory to review: the holder's worktree root when isolated,
    *  else the leader cwd — the reviewer must inspect the claimed work's tree. */
   cwd: string;
+  /** Aborted when the holding's authority is invalidated (release, stop, new
+   *  claim, supersession, or resumed owner execution), so an orphaned reviewer
+   *  cannot keep a child process running against a tree it no longer judges. */
+  signal?: AbortSignal;
 }
 
 export type VerifyReviewOutcome =
@@ -1598,15 +2164,32 @@ function truncated(text: string, cap = 4000): string {
   return text.length <= cap ? text : text.slice(0, Math.max(0, cap - suffix.length)) + suffix;
 }
 
-/** Run the gate as a one-shot Pi worker: a brand-new context that inspects
- *  the working tree itself before answering. Uses the team's model resolution
- *  chain (team default, else Pi default) rather than any role pin. */
-export async function runVerifyReview(input: VerifyReviewInput): Promise<VerifyReviewOutcome> {
-  const outcome = await runPiWorker({
+/** Inspection grant for the gate reviewer: it may run the project's own checks
+ *  but holds no `edit`/`write` tool. The limit is the tool set, not the file
+ *  system: a shell can still write, so treat this as intent-level, not enforced. */
+export const VERIFY_REVIEW_TOOLS: readonly string[] = ["read", "bash", "grep", "find", "ls"];
+
+/** Complete worker options for one gate review. The reviewer runs as a bare Pi
+ *  child: no extension, skill, prompt-template, context-file, or theme discovery
+ *  and no persisted session, so judging a gate cannot load the leader's extension
+ *  surface, run automatic memory learning, write memory files, or leave a session
+ *  record behind. Uses the team's model resolution chain (team default, else the
+ *  leader model) rather than any role pin. */
+export function buildVerifyReviewWorkerOptions(input: VerifyReviewInput): RunPiWorkerOptions {
+  return {
     prompt: buildVerifyReviewPrompt(input),
     cwd: input.cwd || leaderCwd,
-    model: resolveSpawnModel(undefined, getTeamDefaultModel(), leaderModelRef()).model,
-  });
+    tools: [...VERIFY_REVIEW_TOOLS],
+    minimal: true,
+    model: resolveSpawnModel(undefined, getTeamDefaultModel(), currentLeaderModelRef()).model,
+    ...(input.signal ? { signal: input.signal } : {}),
+  };
+}
+
+/** Run the gate as a one-shot bare Pi worker: a brand-new context that inspects
+ *  the working tree itself before answering. */
+export async function runVerifyReview(input: VerifyReviewInput): Promise<VerifyReviewOutcome> {
+  const outcome = await runPiWorker(buildVerifyReviewWorkerOptions(input));
   // A reviewer that did not exit cleanly produced no trustworthy verdict,
   // even if partial output happens to contain a PASS line.
   if (outcome.exitCode !== 0) {
@@ -1685,6 +2268,7 @@ function rearmTaskNotice(taskId: string): void {
 export function wakeIdleTeammates(immediateTaskId?: string): string[] {
   const notified: string[] = [];
   for (const teammate of idleTeammates()) {
+    if (pendingShutdowns.has(teammate.name) || verificationFrozen(teammate)) continue;
     const deliveries = pendingDeliveries.get(teammate.name) ?? [];
     // A terminal direct assignment stays closed until explicit reopen; a board
     // holder must submit rather than drifting into more board work.
@@ -1702,7 +2286,10 @@ export function wakeIdleTeammates(immediateTaskId?: string): string[] {
           ...fresh.filter((task) => task.id !== immediateTaskId),
         ];
     const noticed = prioritized.slice(0, WAKE_NOTICE_TASK_LIMIT);
-    const prompt = buildWakePrompt(deliveries, noticed, dueNotice);
+    const role = !teammate.assignment && teammate.turns === 0
+      ? `=== ROLE PROMPT (${teammate.agent}) ===\n${resolveAgent(teammate.agent, leaderCwd)?.prompt ?? ""}\n\n`
+      : "";
+    const prompt = `${teammate.assignment ? `[agent-teams-assignment:${teammate.assignment.id}]\n` : ""}${role}${buildWakePrompt(deliveries, noticed, dueNotice)}`;
     if (!deliverPrompt(teammate.name, prompt)) continue;
     for (const delivery of deliveries) setPeerDeliveryState(delivery.id, "routed");
     notified.push(teammate.name);
@@ -1714,12 +2301,11 @@ export function wakeIdleTeammates(immediateTaskId?: string): string[] {
       status: "working",
       sequenceEnded: false,
       // A generic peer/harness/board wake-up never opens a terminal direct
-      // assignment. Only leader send_message(reopen=true) owns that transition.
+      // assignment. Only an explicit Work assignment owns that transition.
       ...(teammate.assignment?.kind === "direct" && teammate.assignment.closed
         ? {}
         : { reportSequenceEnded: false }),
       lastOutputAt: Date.now(),
-      stallNoticeSentAt: undefined,
       ...(dueNotice ? { lastNoticeAt: Date.now() } : {}),
     });
   }
@@ -1741,14 +2327,18 @@ export function buildWakePrompt(
   }
   if (includeNotice && claimable.length > 0) {
     const listed = claimable.slice(0, 10).map((task) => `${task.id} (${task.subject})`).join(", ");
-    sections.push(`=== BOARD NOTICE ===\nUnclaimed tasks: ${listed}\nUse task_list for details and task_claim to take one if appropriate for your role.`);
+    sections.push(`=== BOARD NOTICE ===\nUnclaimed tasks: ${listed}\nUse work action=list for details and work action=claim to take one if appropriate for your role.`);
   }
   if (sections.length === 0) return "";
-  return `Wake up. New activity for you:\n\n${sections.join("\n\n")}\n\nHandle the items above, then go idle again.`;
+  const leader = deliveries.find((message) => message.from === "leader" && message.body.startsWith("[agent-teams-assignment:"));
+  const marker = leader?.body.split("\n", 1)[0];
+  return `${marker ? `${marker}\n` : ""}Wake up. New activity for you:\n\n${sections.join("\n\n")}\n\nHandle the items above, then go idle again.`;
 }
 
 function formatDelivery(messages: InboxMessage[]): string {
-  return messages.map((message) => `From ${message.from} · ${message.subject}\n${message.body}`).join("\n\n---\n\n");
+  const leader = messages.find((message) => message.from === "leader" && message.body.startsWith("[agent-teams-assignment:"));
+  const marker = leader?.body.split("\n", 1)[0];
+  return `${marker ? `${marker}\n` : ""}${messages.map((message) => `From ${message.from} · ${message.subject}\n${message.body}`).join("\n\n---\n\n")}`;
 }
 
 // ── Board helpers shared with tools.ts ────────────────────────────
@@ -1763,32 +2353,6 @@ export interface BoardTaskCreationResult {
   supersededTaskIds: string[];
 }
 
-export function formatBoardTaskCreation(subject: string, created: BoardTaskCreationResult): string {
-  const status = created.claimable ? "pending/claimable" : "pending/blocked";
-  const routing = created.notifiedTeammates.length > 0
-    ? `notified=${created.notifiedTeammates.map((name) => `@${name}`).join(",")}`
-    : created.livingTeammates === 0
-      ? "notified=none (no living teammates)"
-      : "notified=none (no eligible idle teammate)";
-  const superseded = (created.supersededTaskIds ?? []).length > 0
-    ? `SUPERSEDED · ${created.supersededTaskIds.join(", ")}`
-    : undefined;
-  const next = !created.claimable
-    ? created.resourceBlocked
-      ? "NEXT · waits for superseded holder or resource owner to release"
-      : "NEXT · waits for dependencies"
-    : created.livingTeammates === 0
-      ? "NEXT · leader: teammate_spawn"
-      : "NEXT · worker: task_claim";
-  return [
-    `BOARD · current session`,
-    `CREATED · ${created.id} · ${status} · ${subject}`,
-    `ROUTING · ${routing}`,
-    superseded,
-    next,
-  ].join("\n");
-}
-
 /** Create a task and synchronously offer it to currently-idle teammates.
  *
  * The normal poll loop still handles later dependency unlocks and queued mail,
@@ -1807,15 +2371,25 @@ export function createBoardTask(input: {
   if (!created.ok) return created;
   for (const task of created.superseded) {
     // A superseded holder intentionally retains its assignment/resource until
-    // it submits failed or stops; tell it to cease writes immediately.
-    if (task.claimedBy) {
+    // it submits failed or stops; cancellation is lifecycle control, so it
+    // must unpark the holder before its feedback can be routed.
+    const holder = task.claimedBy ? getTeammate(task.claimedBy) : undefined;
+    invalidateVerifyGate(task.id);
+    if (holder) unexpectedExecutionParks.delete(`${task.id}:${holder.spawnId}`);
+    for (const [name, pending] of pendingSubmissions) {
+      if (pending.taskId === task.id) pendingSubmissions.delete(name);
+    }
+    if (holder) {
+      archiveDeferredDeliveries(holder);
+      const holding = `${task.id}:${holder.spawnId}`;
+      verifyFailureParks.delete(holding);
+      inconclusiveParks.delete(holding);
       deliverFeedback(
-        task.claimedBy,
+        holder.name,
         `Task superseded: ${task.id}`,
-        `Task "${task.id}" was superseded by "${created.task.id}". Stop work immediately and task_submit with status="failed" to acknowledge cancellation and release its resources.`,
+        `Work Item "${task.id}" was superseded by "${created.task.id}". Stop work immediately and use work action=submit with outcome="failed" to acknowledge cancellation and release its resources.`,
       );
     }
-    verifyingTasks.delete(task.id);
     for (const key of [...verifyFailures.keys()]) {
       if (key.startsWith(`${task.id}:`)) verifyFailures.delete(key);
     }
@@ -1840,21 +2414,6 @@ export function createBoardTask(input: {
   };
 }
 
-export function boardOverview(): Array<import("./types").BoardTask> {
-  return listTasks();
-}
-
-/** Worker-side claim attempt through an exclusive-create marker file. */
-export function attemptClaim(workerName: string, spawnId: string, taskId: string): boolean {
-  return createTaskIntent(claimsDir(boardDirectory()), taskId, {
-    taskId,
-    worker: workerName,
-    spawnId,
-    status: "completed",
-    timestamp: Date.now(),
-  });
-}
-
 /** Worker-side submission through an exclusive-create marker file. */
 export function attemptSubmission(
   workerName: string,
@@ -1867,6 +2426,7 @@ export function attemptSubmission(
     taskId,
     worker: workerName,
     spawnId,
+    assignmentId: getTeammate(workerName)?.assignment?.id,
     status,
     result,
     timestamp: Date.now(),