@fradser/pi-agent-teams 0.10.0 → 1.0.0

package/src/team-machine.ts

@@ -1,7 +1,8 @@
+import { isTaskReplaced } from "@fradser/pi-tasks";
 /**
  * Team machine — resident teammate lifecycle, peer mail routing, task-intent
  * processing, verify gating, and the harness poll loop that wakes idle
- * teammates. The leader model never polls; this loop is the coordination
+ * agents. The leader model never polls; this loop is the coordination
  * engine described by the BDD contract.
  */
 
@@ -15,63 +16,72 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 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 { MODEL_INHERIT_ALIAS, discoverAgents, registerSessionAgent, resolveAgent, type AgentDefinition, type AgentDefinitionInput } from "@fradser/pi-subagents";
 import {
   activeAssignmentConflict,
+  acknowledgeSupersession,
   applyClaimIntent,
-  assignTeammate,
-  boardRevision,
+  assignAgent,
+  bindTask,
+  completeTaskWithOutcome,
+  createBoundWork,
+  tasksRevision,
   claimableTasks,
   clearWorkerRunEvents,
-  completeTask,
   createTask,
-  createDirectWork,
-  discardDirectWork,
   deliverToLeader,
+  discardTask,
   getPeerInboxOffset,
   getState,
-  getTeammate,
+  getAgent,
   getTeamDefaultModel,
-  idleTeammates,
+  idleAgents,
   isPeerDelivered,
-  isValidTeammateName,
-  listTeammates,
-  livingTeammates,
-  loadBoard,
-  markBoardChanged,
+  isValidAgentName,
+  listAgents,
+  livingAgents,
+  loadTasks,
+  markTasksChanged,
   markPeerDelivered,
   getTask,
-  normalizeResources,
   progressRevision,
-  registerTeammate,
-  releaseTask,
-  releaseTasksOf,
-  reclaimDirectWork,
+  registerAgent,
+  failTasksHeldBy,
+  revertUndeliveredTake,
   taskDependenciesMet,
   receiveWorkerMessage,
-  reopenCompletedWork,
+  reopenTask,
+  setTaskContext,
   setPeerInboxOffset,
   rosterRevision,
   setPeerDeliveryState,
   stateRevision,
-  updateTeammate,
-  updateTeammateProgress,
+  updateAgent,
+  updateAgentProgress,
 } from "./state.ts";
 import {
-  appendInboxMessage,
-  boardFilePath,
+  tasksFilePath,
+  buildTaskHandoff,
   claimsDir,
   createTaskIntent,
+  formatTaskHandoff,
+  normalizeResources,
+  readTasksFile,
+  submissionsDir,
+  takeTaskIntent,
+  writeTasksFile,
+  TASK_HOLDER_ENV,
+  type Task,
+  type TaskRefusalResult,
+} from "@fradser/pi-tasks";
+import {
+  appendInboxMessage,
   inboxPath,
-  readBoardFile,
   readJsonlBatch,
   removeSessionStateDir,
   removeWorkerOutbox,
   rosterPath,
   stateFilePath,
-  submissionsDir,
-  takeTaskIntent,
-  writeBoardFile,
   writeRoster,
   writeStateFile,
   workerOutboxPath,
@@ -80,23 +90,38 @@ import { isWorkerEvent } from "./types.ts";
 import {
   deliverFreshAssignment,
   deliverPrompt,
+  deliverResidentPrompt,
+  deliverResidentSteer,
   isCleanExit,
   isFreshAssignmentPending,
-  resolveWorkerTools,
-  sendWorkerSteer,
-  sendWorkerFollowUp,
+  resolveAgentTools,
+  sendAgentSteer,
+  sendAgentFollowUp,
   spawnResident,
-  terminateAllTeammates,
-  terminateTeammate,
-  unknownWorkerTools,
-  WORKER_TOOL_UNIVERSE,
-  type WorkerProcessResult,
+  terminateAllAgents,
+  terminateAgent,
+  unknownAgentTools,
+  type AgentProcessResult,
   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";
+} from "@fradser/pi-subagents";
+import { WORKER_CAPABILITY_TOOLS, WORKER_EXTENSION_PATH } from "./capability-tools.ts";
+import {
+  assertPrivateSessionFiles,
+  ensureAgentWorkspace,
+  inlineDefinitionApplies,
+  AGENT_MEMORY_CAPABILITY_TOOLS,
+  SUBAGENT_ROLE_ENV,
+  SUBAGENT_TOOLS_ENV,
+  SUBAGENT_DEFINITION_ENV,
+  SUBAGENT_SCOPE_ENV,
+  SUBAGENT_EXTENSION_PATH,
+  STREAM_RECOVERY_EXTENSION_PATH,
+  unknownAgentToolsError,
+  type AgentWorkspace,
+} from "@fradser/pi-subagents";
+import { messageTitle, type InboxMessage, type Agent, type WorkerAssignment, type AgentUsage } from "./types.ts";
 import { exactSessionRoute, resolveExactSession } from "./recipient.ts";
-import type { LeaderReport } from "./leader-reports.ts";
+import type { LeaderReport } from "@fradser/pi-subagents";
 
 /** Harness coordination cadence: outbox drain every tick, notices paced. */
 const LIVE_POLL_MS = 500;
@@ -109,9 +134,9 @@ export const NOTICE_PACE_MS = readDurationEnv("PI_TEAMMATE_NOTICE_PACE_MS", DEFA
 export const VERIFY_FAILURE_ESCALATE_AFTER = 2;
 /** Claimable task ids remembered per teammate. markTasksNoticed prunes stale
  *  ids on every notice, so slots are occupied only by currently-claimable
- *  work; the cap is far above any realistic concurrent board size. */
+ *  work; the cap is far above any realistic concurrent tasks size. */
 const MAX_NOTICED_TASK_IDS = 256;
-/** Claimable tasks listed in one wake-prompt board notice. */
+/** Claimable tasks listed in one wake-prompt tasks notice. */
 const WAKE_NOTICE_TASK_LIMIT = 10;
 /** Console-only silence marker: after this long without output the roster
  * shows "stalled". It never notifies the leader or terminates anything. */
@@ -127,7 +152,7 @@ function readDurationEnv(name: string, fallback: number): number {
   return Number.isFinite(value) && value >= 0 ? value : fallback;
 }
 
-export function stallSilenceMs(teammate: Pick<Teammate, "lastOutputAt">, now = Date.now()): number | undefined {
+export function stallSilenceMs(teammate: Pick<Agent, "lastOutputAt">, now = Date.now()): number | undefined {
   if (teammate.lastOutputAt === undefined) return undefined;
   return Math.max(0, now - teammate.lastOutputAt);
 }
@@ -142,14 +167,14 @@ export function formatSilenceDuration(milliseconds: number): string {
 }
 
 /** Console-only silence threshold for the roster "stalled" marker. */
-export function stallThresholdMs(_teammate: Pick<Teammate, "modelOutputSeen" | "activeTool">): number {
+export function stallThresholdMs(_teammate: Pick<Agent, "modelOutputSeen" | "activeTool">): number {
   return STALL_SILENCE_MS;
 }
 
 let livePollTimer: ReturnType<typeof setInterval> | undefined;
 let generation = 0;
 let runtimeStateFile = "";
-let boardFile = "";
+let tasksFile = "";
 let leaderCwd = "";
 /** Live view of the leader session's current model, resolved at spawn time. */
 let leaderModelRef: () => string | undefined = () => undefined;
@@ -220,9 +245,9 @@ function runVerifyGate(
       detail: truncated(`(completion review crashed) ${error instanceof Error ? error.message : String(error)}`),
     }));
 }
-type PendingSubmission = import("./types").TaskIntent & { assignmentId: string; verify: string | undefined };
+type PendingSubmission = import("./types").TaskIntent & { assignmentId: string; verify: string | undefined; rejected?: boolean };
 /** Submitted Work waits for its authoring Worker to settle before a gate can
- * inspect its files. This applies to direct automatic and board submissions. */
+ * inspect its files. This applies to direct automatic and tasks submissions. */
 const pendingSubmissions = new Map<string, PendingSubmission>();
 /** Idle nudges already fired per teammate incarnation (one per transition). */
 const idleNudgesSent = new Set<string>();
@@ -233,7 +258,12 @@ const verifyFailures = new Map<string, VerifyFailureRecord>();
 /** Self-finalize requests delivered per teammate incarnation before escalating to the leader. */
 const selfFinalizeAttempts = new Set<string>();
 const pendingDeliveries = new Map<string, InboxMessage[]>();
-const liveWorktrees = new Map<string, ReturnType<typeof createWorktree>>();
+/** Role and first-input delivery are pinned per incarnation, never re-resolved
+ * when a later send or first idle wake begins. */
+const residentSequences = new Map<string, { rolePrompt: string; roleDelivered: boolean }>();
+/** A correlated control receipt may arrive after result callbacks. Keep the
+ * exact incarnation reserved until that receipt resolves. */
+const pendingResidentInputs = new Set<string>();
 
 // ── Lifecycle ─────────────────────────────────────────────────────
 
@@ -252,31 +282,31 @@ export function initTeamMachine(
   leaderThinkingLevelRef = () => ctx.thinkingLevel;
   const sessionFile = ctx.sessionManager?.getSessionFile();
   runtimeStateFile = stateFilePath(sessionFile, leaderCwd);
-  boardFile = boardFilePath(sessionFile, leaderCwd);
+  tasksFile = tasksFilePath(sessionFile, leaderCwd);
   sendUpdate = hooks.sendUpdate;
   notifyChange = hooks.notifyChange;
-  // The board and runtime dir are keyed per session, so two Leader processes
+  // The tasks 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
+  // Resume: reload a persisted tasks; claims die with their holders. A task set
   // 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);
+    const persisted = readTasksFile(tasksFile);
+    if (persisted) loadTasks(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);
+      const archived = `${tasksFile}.incompatible-${Date.now()}`;
+      fs.renameSync(tasksFile, 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}`;
+      preservation = `The preserved snapshot could not be archived and stays in place: ${tasksFile}`;
     }
     deliverToLeader({ from: "harness", subject: "Incompatible Work snapshot", body: `${detail}\n${preservation}` });
   }
@@ -297,7 +327,7 @@ export function shutdownTeamMachine(): void {
   if (livePollTimer) clearInterval(livePollTimer);
   livePollTimer = undefined;
   runtimeStateFile = "";
-  boardFile = "";
+  tasksFile = "";
   leaderCwd = "";
   leaderModelRef = () => undefined;
   leaderThinkingLevelRef = () => undefined;
@@ -314,6 +344,8 @@ export function shutdownTeamMachine(): void {
   idleNudgesSent.clear();
   selfFinalizeAttempts.clear();
   pendingDeliveries.clear();
+  residentSequences.clear();
+  pendingResidentInputs.clear();
   verifyFailures.clear();
   inconclusiveParks.clear();
   verifyFailureParks.clear();
@@ -322,7 +354,7 @@ export function shutdownTeamMachine(): void {
   snapshotFailure = undefined;
   writtenStateRevision = -1;
   writtenRosterRevision = -1;
-  writtenBoardRevision = -1;
+  writtenTasksRevision = -1;
   writtenProgressRevision = -1;
   lastStateWriteAt = 0;
 }
@@ -377,21 +409,21 @@ export function currentLeaderThinkingLevel(): LeaderThinkingLevel | undefined {
 }
 
 /** Terminate every resident teammate; returns unconfirmed-close diagnostics. */
-export async function teardownTeammates(): Promise<string[]> {
+export async function teardownAgents(): Promise<string[]> {
   // Session shutdown is an intentional lifecycle transition. Mark every
   // resident before signalling so close callbacks do not misclassify normal
   // session teardown as an unexpected crash and enqueue a follow-up turn.
-  for (const teammate of livingTeammates()) pendingShutdowns.add(teammate.name);
-  const results = await terminateAllTeammates();
+  for (const teammate of livingAgents()) pendingShutdowns.add(teammate.name);
+  const results = await terminateAllAgents();
   const diagnostics: string[] = [];
   for (const result of results) {
     if (!result.confirmedClosed) diagnostics.push(`Agent ${result.name} could not be confirmed closed.`);
-    updateTeammate(result.name, { status: "stopped" });
+    updateAgent(result.name, { status: "stopped" });
   }
   return diagnostics;
 }
 
-/** Remove the current session's runtime dir; the task board persists. */
+/** Remove the current session's runtime dir; the task set persists. */
 export function removeRuntimeDir(ctx: Pick<ExtensionContext, "sessionManager" | "cwd">): void {
   removeSessionStateDir(ctx.sessionManager?.getSessionFile(), ctx.cwd || process.cwd());
 }
@@ -417,7 +449,7 @@ let snapshotFailure: { count: number; reported: boolean; detail: string } | unde
  *  every artifact. */
 let writtenStateRevision = -1;
 let writtenRosterRevision = -1;
-let writtenBoardRevision = -1;
+let writtenTasksRevision = -1;
 let writtenProgressRevision = -1;
 let lastStateWriteAt = 0;
 /** Roughly 2 poll ticks: the debug snapshot follows progress, but not per token. */
@@ -466,23 +498,23 @@ function claimLeaderLease(): void {
 function flushSnapshots(): void {
   const stateFile = requireStateFile();
   const rosterRev = rosterRevision();
-  const boardRev = boardRevision();
+  const tasksRev = tasksRevision();
   const stateRev = stateRevision();
   const progressRev = progressRevision();
   const needsRoster = rosterRev !== writtenRosterRevision;
-  const needsBoard = boardRev !== writtenBoardRevision;
+  const needsTasks = tasksRev !== writtenTasksRevision;
   // 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;
+  if (!needsRoster && !needsTasks && !needsState) return;
   try {
     if (needsState) writeStateFile(stateFile, getState());
     if (needsRoster) {
-      writeRoster(rosterPath(stateFile), livingTeammates().map((t) => ({
+      writeRoster(rosterPath(stateFile), livingAgents().map((t) => ({
         name: t.name,
-        agent: t.agent,
+        role: t.role,
         spawnId: t.spawnId,
         status: t.status,
         tools: t.tools,
@@ -490,7 +522,7 @@ function flushSnapshots(): void {
         assignment: t.assignment,
       })));
     }
-    if (needsBoard && boardFile) writeBoardFile(boardFile, getState().tasks);
+    if (needsTasks && tasksFile) writeTasksFile(tasksFile, getState().tasks);
     // Only a fully successful flush advances the revisions, so a failed write
     // stays dirty and the next poll retries it.
     if (needsState) {
@@ -499,7 +531,7 @@ function flushSnapshots(): void {
       lastStateWriteAt = Date.now();
     }
     if (needsRoster) writtenRosterRevision = rosterRev;
-    if (needsBoard) writtenBoardRevision = boardRev;
+    if (needsTasks) writtenTasksRevision = tasksRev;
     snapshotFailure = undefined;
   } catch (error) {
     // The next poll retries. A transient failure stays quiet, but a persistent
@@ -526,7 +558,7 @@ export function publishStateSnapshot(): void {
 }
 
 export function ensureLivePoll(): void {
-  const busy = livingTeammates().length > 0 || verifyingTasks.size > 0 || pendingDeliveries.size > 0;
+  const busy = livingAgents().length > 0 || verifyingTasks.size > 0 || pendingDeliveries.size > 0;
   if (busy && !livePollTimer && runtimeStateFile) {
     livePollTimer = setInterval(() => {
       try {
@@ -553,9 +585,9 @@ function tick(): void {
 
 // ── Spawning ──────────────────────────────────────────────────────
 
-export function spawnTeammate(input: {
+export function spawnAgent(input: {
   name: string;
-  agent: string;
+  role: string;
   workId?: string;
   /** Internal binding of an existing Work Item, never exposed as a public field. */
   existingWorkId?: string;
@@ -565,17 +597,17 @@ export function spawnTeammate(input: {
   resources?: string[];
   verify?: string;
   handoffFrom?: string;
+  /** Explicit invocation tools may narrow an existing role, never widen it. */
+  tools?: string[];
   definition?: Omit<AgentDefinitionInput, "name" | "tools"> & {
     tools?: string[];
-    persist?: boolean;
-    persistScope?: "project" | "project-local";
   };
-}): { ok: true; teammate: Teammate; readiness?: Promise<string | undefined> } | { ok: false; error: string } {
+}): { ok: true; agent: Agent; readiness?: Promise<string | undefined> } | { ok: false; error: string } {
   const stateFile = requireStateFile();
   const invalid = validateSpawnInput(input);
   if (invalid) return { ok: false, error: invalid };
   if (input.handoffFrom) {
-    const predecessor = getTeammate(input.handoffFrom);
+    const predecessor = getAgent(input.handoffFrom);
     if (!predecessor) return { ok: false, error: `Cannot hand off from @${input.handoffFrom}: teammate not found.` };
     if (predecessor.status !== "stopped") {
       return { ok: false, error: `Cannot hand off from living @${input.handoffFrom}. Shut it down or wait for it to stop before spawning a successor.` };
@@ -585,43 +617,73 @@ export function spawnTeammate(input: {
   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);
+  const resolved = resolveAgent(input.role, 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.
-  const requestedTools = input.definition && inlineDefinitionApplies(resolved) ? input.definition.tools : resolved?.tools;
-  const unknownTools = unknownWorkerTools(requestedTools);
-  if (unknownTools.length > 0) return { ok: false, error: unknownWorkerToolsError(unknownTools) };
+  const requestedTools = input.tools ?? (input.definition && inlineDefinitionApplies(resolved) ? input.definition.tools : resolved?.tools);
+  if (resolved && input.tools !== undefined && !(input.definition && inlineDefinitionApplies(resolved))) {
+    const widened = input.tools.filter(tool => !resolved.tools.includes(tool));
+    if (widened.length > 0) return { ok: false, error: `Invocation cannot widen @${resolved.name}'s tool grant: ${widened.join(", ")}.` };
+  }
+  const unknownTools = unknownAgentTools(requestedTools, [
+    ...AGENT_MEMORY_CAPABILITY_TOOLS,
+    ...WORKER_CAPABILITY_TOOLS,
+  ]);
+  if (unknownTools.length > 0) return { ok: false, error: unknownAgentToolsError(unknownTools, WORKER_CAPABILITY_TOOLS) };
   let agent: AgentDefinition | undefined = resolved;
   if (input.definition && inlineDefinitionApplies(resolved)) {
     try {
       const generated = input.definition;
       const roleInput: AgentDefinitionInput = {
-        name: input.agent,
+        name: input.role,
         description: generated.description,
-        tools: generated.tools ?? [],
+        tools: requestedTools ?? [],
         model: generated.model,
         verify: generated.verify,
-        worktree: generated.worktree,
         prompt: generated.prompt,
       };
-      agent = generated.persist
-        ? persistAgentDefinition(roleInput, generated.persistScope ?? "project-local", leaderCwd)
-        : registerSessionAgent(roleInput);
+      agent = registerSessionAgent(roleInput);
     } catch (error) {
       return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
   }
-  if (!agent) return { ok: false, error: unknownAgentError(input.agent, leaderCwd) };
-
-  let isolation: Teammate["isolation"] = "none";
-  let workerCwd = leaderCwd;
-  if (agent.worktree) {
-    const worktree = createWorktree(workerCwd, `${input.name}-${Date.now()}`);
-    if ("error" in worktree) return { ok: false, error: `Cannot isolate teammate: ${worktree.error}` };
-    liveWorktrees.set(input.name, worktree);
-    isolation = "worktree";
-    workerCwd = worktree.cwd;
+  if (!agent) return { ok: false, error: unknownAgentError(input.role, leaderCwd) };
+
+  // Disk scope is the only durable identity declaration. Every disk role has
+  // Memory; a session role cannot acquire it through an invocation flag.
+  const durable = agent.scope !== "session";
+  if (requestedTools?.some((tool) => AGENT_MEMORY_CAPABILITY_TOOLS.includes(tool)) && !durable) {
+    return { ok: false, error: agentMemoryUnavailableError(agent.name) };
+  }
+
+  // Both packages contribute a worker extension to one child. `--extension` is
+  // repeatable and `--no-extensions` still loads explicit paths, so neither
+  // package has to know about the other; each declares its own capability tools.
+  // The subagents contribution is conditional: loading its extension into a
+  // child that has no memory folder would register nothing and advertise a tool
+  // the child cannot use.
+  const memoryEnabled = durable;
+  const capabilityTools = [
+    ...(memoryEnabled ? AGENT_MEMORY_CAPABILITY_TOOLS : []),
+    ...WORKER_CAPABILITY_TOOLS,
+  ];
+  const workerExtensions = [
+    STREAM_RECOVERY_EXTENSION_PATH,
+    ...(memoryEnabled ? [SUBAGENT_EXTENSION_PATH] : []),
+    WORKER_EXTENSION_PATH,
+  ];
+  const executionTools = requestedTools ?? agent.tools;
+  const effectiveTools = resolveAgentTools(executionTools, capabilityTools);
+  let workspace: AgentWorkspace | undefined;
+  try {
+    // Provision only data for an existing disk identity, never an agent.md.
+    if (durable) workspace = ensureAgentWorkspace({ agentName: agent.name, cwd: leaderCwd });
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
   }
+  const workerCwd = workspace?.cwd ?? leaderCwd;
+  const sessionDir = workspace?.sessionDir;
+  const hasSavedSession = sessionDir && assertPrivateSessionFiles(sessionDir);
 
   const spawnId = randomUUID();
   const effectiveKickoff = buildSuccessorHandoff(input.prompt, input.handoffFrom);
@@ -632,14 +694,10 @@ export function spawnTeammate(input: {
       : [];
   const conflict = activeAssignmentConflict(directResources);
   if (conflict) {
-    discardWorktreeQuietly(input.name);
     return { ok: false, error: `Direct assignment resources conflict with @${conflict.name}'s ${conflict.assignment?.kind} assignment "${conflict.assignment?.id}".` };
   }
-  const registered = registerTeammate(newTeammate(input, spawnId, isolation, workerCwd));
-  if (!registered.ok) {
-    discardWorktreeQuietly(input.name);
-    return { ok: false, error: registered.error };
-  }
+  const registered = registerAgent(newTeammate(input, spawnId, workerCwd));
+  if (!registered.ok) return { ok: false, error: registered.error };
 
   const spawnModel = resolveSpawnModel(input.model ?? agent.model, getTeamDefaultModel(), currentLeaderModelRef());
   // Record the grant before the first wake: a role derived without tools shows
@@ -647,26 +705,30 @@ export function spawnTeammate(input: {
   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}`,
+      ? bindTask(input.existingWorkId, input.name, assignment, { from: ["pending"] })
+      : createBoundWork({
+        id: getAgent(input.name)?.workId ?? `work:${spawnId}`,
         subject: effectiveKickoff ? messageTitle(effectiveKickoff) : "Direct work",
         description: effectiveKickoff,
         resources: directResources,
         verify: input.verify,
-        workerName: input.name,
+        holder: input.name,
         assignment,
       });
     if (!directWork.ok) {
-      updateTeammate(input.name, { status: "stopped" });
-      discardWorktreeQuietly(input.name);
-      return { ok: false, error: directWork.error };
+      updateAgent(input.name, { status: "stopped" });
+      return { ok: false, error: directWork.reason };
     }
   }
-  updateTeammate(input.name, {
+  residentSequences.set(spawnId, { rolePrompt: agent.prompt, roleDelivered: false });
+  updateAgent(input.name, {
+    scope: agent.scope,
+    source: agent.source,
+    projectCwd: leaderCwd,
+    ...(workspace ? { workspacePath: workspace.workspacePath, sessionDir } : {}),
     model: spawnModel.model,
     context: input.context === undefined ? "fresh" : "fork",
-    tools: resolveWorkerTools(agent.tools),
+    tools: effectiveTools,
     ...(assignment ? {} : { assignment }),
   });
   // Flush before the kickoff is written: a fast child must not read a stale
@@ -678,30 +740,39 @@ export function spawnTeammate(input: {
   // 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; });
+  pendingResidentInputs.add(spawnId);
+  void readiness.then(() => { pendingResidentInputs.delete(spawnId); });
   const started = spawnResident({
-    workerName: input.name,
+    agentName: input.name,
     description: assignment ? `[agent-teams-assignment:${assignment.id}]\n` + buildKickoffPrompt(
       input.name,
-      input.agent,
+      input.role,
       agent.prompt,
       effectiveKickoff,
-      isolation,
     ) : undefined,
     model: spawnModel.model,
     thinking: currentLeaderThinkingLevel(),
     context: input.context,
-    tools: agent.tools,
+    tools: executionTools,
+    extensions: workerExtensions,
+    capabilityTools,
     cwd: workerCwd,
-    env: teammateEnv(stateFile, input, spawnId, agent.verify),
+    session: durable ? (hasSavedSession ? "resume" : "persist") : "none",
+    ...(sessionDir ? { sessionDir } : {}),
+    // Both kinds launch in the original project. Scratch is data, not a new
+    // trusted checkout; do not force project approval merely for durability.
+    env: teammateEnv(stateFile, input, spawnId, agent, effectiveTools),
     onUpdate: (progress) => {
       applyProgress(input.name, spawnId, progress);
-      if (progress.controlError) settleReadiness(progress.controlError);
-      else if (progress.ready) settleReadiness(undefined);
+      if (!assignment) {
+        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}`, false);
+      if (getAgent(input.name)?.spawnId !== spawnId) return;
+      if (input.existingWorkId) revertUndeliveredTake(input.existingWorkId, input.name, `Agent failed to start: ${error.message}`);
       failSpawn(input.name, error.message, input.existingWorkId);
     },
     onExit: (result) => {
@@ -710,37 +781,66 @@ export function spawnTeammate(input: {
     },
   });
   if ("error" in started) {
-    if (input.existingWorkId) releaseTask(input.existingWorkId, `Agent failed to start: ${started.error}`, false);
-    else if (assignment) discardDirectWork(getTeammate(input.name)?.workId ?? `work:${spawnId}`, input.name);
+    settleReadiness(started.error);
+    if (input.existingWorkId) revertUndeliveredTake(input.existingWorkId, input.name, `Agent failed to start: ${started.error}`);
+    else if (assignment) discardTask(getAgent(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 });
-  // Keep starting until model activity or the unassigned child's native
-  // readiness acknowledgement arrives; spawning alone does not prove idle.
+  updateAgent(input.name, { pid: started.pid, envPolicy: started.envPolicy });
+  if (assignment) {
+    // Attach both outcomes immediately, even for synchronous internal callers.
+    // A writable pipe proves neither accepted input nor completed execution.
+    const rejectInput = (error: string) => {
+      if (getAgent(input.name)?.spawnId === spawnId) updateAgent(input.name, { error });
+      settleReadiness(error);
+    };
+    if (!started.accepted) rejectInput("Resident kickoff input acknowledgement is unavailable.");
+    else void started.accepted.then((accepted) => {
+      const current = getAgent(input.name);
+      if (!accepted) rejectInput("Resident kickoff input was not accepted. Inspect or stop before retrying.");
+      else if (!current || current.spawnId !== spawnId || current.status === "stopped") {
+        rejectInput("Resident exited or was replaced before kickoff input was acknowledged.");
+      } else {
+        // A fast result may settle before the RPC response. Do not revive it.
+        if (current.status === "starting") updateAgent(input.name, { status: "working" });
+        const sequence = residentSequences.get(spawnId);
+        if (sequence) sequence.roleDelivered = true;
+        settleReadiness(undefined);
+      }
+    }).catch((error) => rejectInput(error instanceof Error ? error.message : String(error)));
+  }
+  const contextWorkId = getAgent(input.name)?.workId;
+  if (contextWorkId && workspace) setTaskContext(contextWorkId, { workspacePath: workspace.workspacePath });
+  // Keep starting until native readiness or accepted kickoff input; settlement
+  // leaves both temporary and durable incarnations idle, never closed.
   publishStateSnapshot();
   ensureLivePoll();
   notifyChange();
-  return { ok: true, teammate: getTeammate(input.name)!, ...(assignment ? {} : { readiness }) };
+  return { ok: true, agent: getAgent(input.name)!, readiness };
 }
 
 /** True when a spawn's inline definition should create or replace the role:
  *  nothing resolved, or only a session-scoped generated role did. Filesystem
- *  scopes are user-owned and always win over inline input. */
-export function inlineDefinitionApplies(resolved: AgentDefinition | undefined): boolean {
-  return !resolved || resolved.scope === "session";
-}
+ *  scopes are user-owned and always win over inline input.
+ *
+ *  Owned by `@fradser/pi-subagents` and re-exported here, because the standalone
+ *  spawner has to answer the same question. Two copies of this rule is how the
+ *  two spawn paths came to disagree about which role a child received. */
+export { inlineDefinitionApplies };
 
-/** Spawn failure for execution-tool ids outside the teammate universe. */
-export function unknownWorkerToolsError(unknown: readonly string[]): string {
-  return [
-    `Unknown tool id${unknown.length === 1 ? "" : "s"} for a teammate: ${unknown.join(", ")}.`,
-    "A teammate child runs a bare pi process (--no-extensions), so only pi built-in tools plus the teammate capability set can be granted.",
-    `Valid ids: ${WORKER_TOOL_UNIVERSE.join(", ")}.`,
-    "MCP or project-extension tools cannot reach a teammate; perform that work in the leader session instead.",
-  ].join(" ");
+/** A session role has no durable Memory capability to contribute. */
+export function agentMemoryUnavailableError(name: string): string {
+  return `Temporary Agent "${name}" has no Agent Memory. Remove ${AGENT_MEMORY_CAPABILITY_TOOLS.join(" and ")} from its tools; durable Memory belongs only to a user-authored disk agent.md.`;
 }
 
+/** Spawn failure for execution-tool ids outside the teammate universe.
+ *
+ *  Re-exported from `@fradser/pi-subagents`, which owns the universe and the
+ *  message beside it: the standalone spawner refuses the same ids for the same
+ *  reason, and a second copy of this text is a second copy to drift. */
+export { unknownAgentToolsError };
+
 /** Spawn failure for an unresolvable agent name. Definitions resolve live at
  *  spawn time, so the available-agents list in the cached session guidance can
  *  go stale (e.g. another session removed the file); name every checked scope
@@ -749,39 +849,37 @@ export function unknownAgentError(name: string, cwd: string): string {
   const available = [...discoverAgents(cwd).keys()];
   return [
     `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.`,
+    `Checked: ${cwd}/.pi/agents/<name>.local/agent.md, ${cwd}/.pi/agents/<name>/agent.md, ${path.join(getAgentDir(), "agents", "<name>", "agent.md")}, 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 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.',
+    'Recover with agent action=start using an existing name, or supply description and role_prompt derived from references/agent-roles.md for a temporary role.',
     `Available now: ${available.length > 0 ? available.join(", ") : "(none)"}.`,
   ].join(' ');
 }
 
 function validateSpawnInput(input: { name: string }): string | undefined {
-  if (!isValidTeammateName(input.name)) {
+  if (!isValidAgentName(input.name)) {
     return `Invalid teammate name "${input.name}". Use letters, digits, dots, dashes, underscores.`;
   }
-  if (livingTeammates().some((t) => t.name === input.name)) {
+  if (livingAgents().some((t) => t.name === input.name)) {
     return `A living teammate named "${input.name}" already exists.`;
   }
   return undefined;
 }
 
 function newTeammate(
-  input: { name: string; agent: string; workId?: string },
+  input: { name: string; role: string; workId?: string },
 
   spawnId: string,
-  isolation: Teammate["isolation"],
   workerCwd: string,
-): Teammate {
+): Agent {
   return {
     name: input.name,
-    agent: input.agent,
+    role: input.role,
     spawnId,
     workId: input.workId,
     pid: 0,
     status: "starting",
     cwd: workerCwd,
-    isolation,
     turns: 0,
     createdAt: Date.now(),
     updatedAt: Date.now(),
@@ -805,35 +903,46 @@ export function directAssignment(
 export function resolveDirectResources(resources: string[] | undefined, handoffFrom: string | undefined): string[] {
   const explicit = normalizeResources(resources);
   if (explicit.length > 0) return explicit;
-  const prior = handoffFrom ? getTeammate(handoffFrom) : undefined;
+  const prior = handoffFrom ? getAgent(handoffFrom) : undefined;
   return normalizeResources(prior?.assignment?.resources ?? prior?.lastAssignment?.resources);
 }
 
 export function buildSuccessorHandoff(kickoff: string | undefined, handoffFrom: string | undefined): string | undefined {
   if (!handoffFrom?.trim()) return kickoff;
-  const prior = getTeammate(handoffFrom);
+  const prior = getAgent(handoffFrom);
   const reports = getState().leaderMailbox
     .filter((message) => message.from === handoffFrom)
     .slice(-3)
-    .map((message) => `- ${message.subject}: ${truncated(message.body, 1000)}`)
-    .join("\n");
+    .map((message) => `${message.subject}: ${truncated(message.body, 1000)}`);
   const assignment = prior?.assignment ?? prior?.lastAssignment;
   const taskId = prior?.currentTaskId ?? prior?.lastTaskId;
-  const handoff = [
+  // A structured brief rather than concatenated prose. @fradser/pi-tasks owns the shape, so
+  // a successor handoff, a recheck, and a standalone tasks all produce the same
+  // sections, and an oversized brief is clipped and marked instead of silently
+  // truncated. Prior reports go in `priorFindings` deliberately: that is the field
+  // a recheck must not lose when a reopen clears the result.
+  const { handoff } = buildTaskHandoff({
+    candidate: prior?.cwd ? `workspace ${prior.cwd}` : undefined,
+    delta: assignment ? `${assignment.kind} ${assignment.id}` : "assignment unavailable",
+    verification: taskId ? `prior tasks claim ${taskId}` : "no prior tasks claim",
+    priorFindings: reports.length > 0 ? reports : undefined,
+    outstanding: [
+      "Verify current files yourself; do not claim the predecessor's tasks Work unless the leader explicitly assigns it.",
+    ],
+  });
+  const brief = [
     `=== SUCCESSOR HANDOFF FROM @${handoffFrom} ===`,
-    assignment ? `Prior assignment: ${assignment.kind} ${assignment.id}` : "Prior assignment: unavailable",
-    taskId ? `Prior board claim: ${taskId}` : "Prior board claim: none",
-    reports ? `Recent leader reports:\n${reports}` : "Recent leader reports: none",
-    "Verify current files yourself; do not claim the predecessor's board task unless the leader explicitly assigns it.",
-  ].join("\n");
-  return [kickoff?.trim(), handoff].filter(Boolean).join("\n\n");
+    formatTaskHandoff(handoff),
+  ].filter(Boolean).join("\n");
+  return [kickoff?.trim(), brief].filter(Boolean).join("\n\n");
 }
 
 function teammateEnv(
   stateFile: string,
-  input: { name: string; agent: string },
+  input: { name: string; role: string },
   spawnId: string,
-  verify: string | undefined,
+  definition: AgentDefinition,
+  tools: readonly string[],
 ): Record<string, string | undefined> {
   return {
     PI_TEAMMATE_WORKER_NAME: input.name,
@@ -841,11 +950,25 @@ function teammateEnv(
     PI_TEAMMATE_OUTBOX_FILE: workerOutboxPath(stateFile, input.name, spawnId),
     PI_TEAMMATE_INBOX_FILE: inboxPath(stateFile, input.name),
     PI_TEAMMATE_ROSTER_FILE: rosterPath(stateFile),
-    PI_TEAMMATE_BOARD_FILE: boardFile,
-    PI_TEAMMATE_CLAIMS_DIR: claimsDir(boardDirectory()),
-    PI_TEAMMATE_SUBMISSIONS_DIR: submissionsDir(boardDirectory()),
-    PI_TEAMMATE_ROLE_AGENT: input.agent,
-    PI_TEAMMATE_VERIFY_DEFAULT: verify ?? "",
+    PI_TEAMMATE_TASKS_FILE: tasksFile,
+    PI_TEAMMATE_CLAIMS_DIR: claimsDir(taskDirectory()),
+    PI_TEAMMATE_SUBMISSIONS_DIR: submissionsDir(taskDirectory()),
+    PI_TEAMMATE_ROLE_AGENT: input.role,
+    // The tasks's own binding, named by the tasks. `PI_TEAMMATE_WORKER_NAME` is
+    // this package's private vocabulary; a child that read it to decide who it is
+    // on the tasks would couple the tasks to this package's naming.
+    [TASK_HOLDER_ENV]: input.name,
+    PI_TEAMMATE_VERIFY_DEFAULT: definition.verify ?? "",
+    // The subagent worker extension reads these. Named for that package rather
+    // than reusing PI_TEAMMATE_*, so the execution layer never has to learn this
+    // package's vocabulary.
+    ...(definition.scope !== "session" ? {
+      [SUBAGENT_ROLE_ENV]: definition.name,
+      [SUBAGENT_TOOLS_ENV]: tools.join(","),
+      [SUBAGENT_DEFINITION_ENV]: definition.source,
+      [SUBAGENT_SCOPE_ENV]: definition.scope,
+    } : {}),
+    PI_SUBAGENT_PROJECT_CWD: leaderCwd,
   };
 }
 
@@ -854,41 +977,36 @@ export function buildKickoffPrompt(
   agentName: string,
   rolePrompt: string,
   kickoff: string | undefined,
-  isolation: Teammate["isolation"],
 ): string {
   const header = [
-    `You are a FULLY AUTONOMOUS resident teammate named "${name}" (agent: ${agentName}) in a pi multi-agent team.`,
+    `You are a FULLY AUTONOMOUS resident agent named "${name}" (role: ${agentName}) in a pi multi-agent team.`,
     "You stay alive between tasks. The harness wakes you with new prompts when",
-    "messages arrive for you or when the task board has unclaimed work.",
-    isolation === "worktree" ? "You are working inside your own dedicated git worktree." : "",
+    "messages arrive for you or when the task set has unclaimed work.",
+    `Original project: ${leaderCwd}. A private scratch cwd is not a checkout; project edits change the original working tree directly.`,
   ].filter(Boolean).join(" ");
-  const roleSection = `=== ROLE PROMPT (${agentName}) ===\n${rolePrompt}`;
+  // A role may state a purpose without instructions, so an empty body is said
+  // rather than printed as a heading with nothing under it — a child told "ROLE
+  // PROMPT (x) ===" and nothing else cannot tell whether it was given a role.
+  const roleSection = rolePrompt.trim()
+    ? `=== ROLE PROMPT (${agentName}) ===\n${rolePrompt.trim()}`
+    : `=== ROLE (${agentName}) ===\nThis role states what you are for and carries no standing instructions. Take the task below as it comes.`;
   const taskSection = kickoff?.trim()
-    ? `=== 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)";
+    ? `=== KICKOFF TASK ===\n${kickoff.trim()}\n\nExecute this assigned task directly; this task text is the whole assignment, so use task tools only when the assignment requires them.`
+    : "=== KICKOFF TASK ===\n(none yet — list the tasks with task action=list and take one with task update status=in_progress)";
   return `${header}\n\n${roleSection}\n\n${taskSection}`;
 }
 
-function buildFreshAssignmentPrompt(teammate: Teammate, assignmentId: string, task: string): string {
+function buildFreshAssignmentPrompt(teammate: Agent, assignmentId: string, task: string): string {
   return `[agent-teams-assignment:${assignmentId}]\n${buildKickoffPrompt(
     teammate.name,
-    teammate.agent,
-    resolveAgent(teammate.agent, leaderCwd)?.prompt ?? "",
+    teammate.role,
+    residentSequences.get(teammate.spawnId)?.rolePrompt ?? resolveAgent(teammate.role, leaderCwd)?.prompt ?? "",
     task,
-    teammate.isolation,
   )}`;
 }
 
-function discardWorktreeQuietly(name: string): void {
-  const handle = liveWorktrees.get(name);
-  if (!handle || "error" in handle) return;
-  liveWorktrees.delete(name);
-  // A failed spawn never produced work; the empty branch goes too.
-  discardWorktree(handle);
-}
-
-function boardDirectory(): string {
-  return path.dirname(boardFile);
+function taskDirectory(): string {
+  return path.dirname(tasksFile);
 }
 
 export function applyProgress(name: string, spawnId: string, progress: {
@@ -899,18 +1017,18 @@ export function applyProgress(name: string, spawnId: string, progress: {
   finalResponse?: boolean;
   modelOutputSeen?: boolean;
   ready?: boolean;
-  usage?: WorkerUsage;
+  usage?: AgentUsage;
   controlError?: string;
 }): void {
-  const teammate = getTeammate(name);
+  const teammate = getAgent(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 });
+    updateAgent(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 });
+    sendUpdate({ agent: name, spawnId, body: progress.controlError, origin: "harness", harnessEvent: { type: "control-rejected", subject: `@${name} control rejected` }, finished: false });
   }
-  updateTeammateProgress(name, teammate.spawnId, {
+  updateAgentProgress(name, teammate.spawnId, {
     liveText: progress.text,
     activeTool: progress.activeTool,
     liveThinking: progress.liveThinking,
@@ -919,13 +1037,13 @@ export function applyProgress(name: string, spawnId: string, progress: {
     modelOutputSeen: progress.modelOutputSeen,
     usage: progress.usage,
   });
-  updateTeammate(name, { lastOutputAt: Date.now(), ...(progress.finalResponse === false ? { status: "working" } : {}) });
+  updateAgent(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,
+      agent: name,
       spawnId,
       origin: "harness",
       harnessEvent: { type: "review-invalidated", subject: `Verification invalidated · ${getTask(teammate.currentTaskId)?.subject ?? "Work"}` },
@@ -934,13 +1052,14 @@ export function applyProgress(name: string, spawnId: string, progress: {
     });
   }
   if (progress.finalResponse && teammate.status !== "idle") {
-    updateTeammate(name, { status: "idle", activeTool: undefined });
+    updateAgent(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)!);
+    if (pending?.spawnId === spawnId && getAgent(name)?.assignment?.id === pending.assignmentId && !pending.rejected) {
+      // A review owns its binding; an ungated submission stays pending until accepted.
+      if (pending.verify?.trim()) pendingSubmissions.delete(name);
+      archiveDeferredDeliveries(getAgent(name)!);
       beginVerifyOrComplete(pending, pending.verify);
     }
     nudgeIfUnfinalized(name, spawnId);
@@ -966,10 +1085,10 @@ const verifyFailureParks = new Map<string, { worker: string; spawnId: string }>(
 /** Owner execution observed during review; explicit Leader recovery is required. */
 const unexpectedExecutionParks = new Set<string>();
 
-type FinishIdentity = Pick<LeaderReport, "teammate" | "agent" | "spawnId" | "assignmentId" | "finished">;
+type FinishIdentity = Pick<LeaderReport, "agent" | "spawnId" | "assignmentId" | "finished">;
 
 function finishKey(report: FinishIdentity): string {
-  return `${report.teammate ?? report.agent ?? "teammate"}:${report.spawnId ?? "session"}:${report.assignmentId ?? "unassigned"}`;
+  return `${report.agent ?? "agent"}:${report.spawnId ?? "session"}:${report.assignmentId ?? "unassigned"}`;
 }
 
 /** Announce each assignment attempt once, including later work in the same process. */
@@ -983,15 +1102,17 @@ export function markTeammateFinished(report: FinishIdentity): boolean {
 
 /** Only an open current assignment can owe a final result. */
 export function hasUnfinalizedReport(name: string): boolean {
-  const teammate = getTeammate(name);
+  const teammate = getAgent(name);
+  const pending = pendingSubmissions.get(name);
+  const submitted = pending?.spawnId === teammate?.spawnId && pending?.assignmentId === teammate?.assignment?.id;
   return Boolean(teammate?.assignment && !teammate.assignment.closed
-    && !teammate.reportSequenceEnded && !verificationFrozen(teammate));
+    && !teammate.reportSequenceEnded && !submitted && !verificationFrozen(teammate));
 }
 
 /** One light reminder per idle transition when work looks unfinished. */
 function nudgeIfUnfinalized(name: string, spawnId: string): void {
   if (!hasUnfinalizedReport(name)) return;
-  const key = `${name}:${spawnId}:${getTeammate(name)?.assignment?.id}`;
+  const key = `${name}:${spawnId}:${getAgent(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.
@@ -999,16 +1120,16 @@ function nudgeIfUnfinalized(name: string, spawnId: string): void {
     deliverFeedback(
       name,
       "Assignment not finalized",
-      `Current assignment "${getTeammate(name)?.assignment?.id ?? "unassigned"}" has no automatic final result yet. Return a final answer or submit the current Work outcome.`,
+      `Current assignment "${getAgent(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 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.`;
+  const reminder = `@${name} is idle but current assignment "${getAgent(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,
+    agent: name,
     body: reminder,
     origin: "harness",
     harnessEvent: { type: "unfinalized-report", subject: `@${name} idle without terminal report` },
@@ -1017,15 +1138,15 @@ function nudgeIfUnfinalized(name: string, spawnId: string): void {
 }
 
 function failSpawn(name: string, error: string, existingWorkId?: string): void {
-  const teammate = getTeammate(name);
+  const teammate = getAgent(name);
   if (!existingWorkId && teammate?.assignment?.kind === "direct" && teammate.currentTaskId) {
-    discardDirectWork(teammate.currentTaskId, name);
+    discardTask(teammate.currentTaskId, name);
   } else {
-    releaseTasksOf(name, `Agent failed to start: ${error}`);
+    failTasksHeldBy(name, `Agent failed to start: ${error}`);
   }
-  discardWorktreeQuietly(name);
-  updateTeammate(name, { status: "stopped", error });
+  updateAgent(name, { status: "stopped", error });
   if (teammate) {
+    residentSequences.delete(teammate.spawnId);
     clearWorkerRunEvents(name, teammate.spawnId);
     removeWorkerOutbox(requireStateFile(), name, teammate.spawnId);
   }
@@ -1040,19 +1161,19 @@ function failSpawn(name: string, error: string, existingWorkId?: 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);
+export async function shutdownAgentExact(name: string, spawnId: string): Promise<{ ok: true; body: string } | { ok: false; error: string }> {
+  const existing = getAgent(name);
   if (!existing || existing.spawnId !== spawnId || existing.status === "stopped") {
     return { ok: false, error: `No living session named "${exactSessionRoute(name, spawnId)}".` };
   }
-  return shutdownTeammate(name);
+  return shutdownAgent(name);
 }
 
-export async function shutdownTeammate(name: string): Promise<{ ok: true; body: string } | { ok: false; error: string }> {
-  const teammate = getTeammate(name);
+export async function shutdownAgent(name: string): Promise<{ ok: true; body: string } | { ok: false; error: string }> {
+  const teammate = getAgent(name);
   if (!teammate || teammate.status === "stopped") return { ok: false, error: `No living teammate named "${name}".` };
   pendingShutdowns.add(name);
-  const terminated = await terminateTeammate(name);
+  const terminated = await terminateAgent(name);
   if (terminated.outcome === "unconfirmed") {
     return { ok: false, error: `Agent @${name} could not be confirmed closed; shutdown remains pending.` };
   }
@@ -1060,14 +1181,15 @@ export async function shutdownTeammate(name: string): Promise<{ ok: true; body:
     rememberBounded(confirmedStopTimes, teammate.spawnId, Date.now());
     // The child was already gone; synthesize the close bookkeeping.
     pendingShutdowns.delete(name);
-    const released = releaseTasksOf(name, "Agent was stopped.");
+    const released = failTasksHeldBy(name, "Agent was stopped.");
     for (const task of released) {
       clearInconclusiveForHolding(task.id, teammate.spawnId);
       invalidateVerifyGate(task.id);
       rearmTaskNotice(task.id);
     }
-    updateTeammate(name, { status: "stopped", activeTool: undefined });
+    updateAgent(name, { status: "stopped", activeTool: undefined });
     pendingDeliveries.delete(name);
+    residentSequences.delete(teammate.spawnId);
     idleNudgesSent.delete(`${name}:${teammate.spawnId}`);
     selfFinalizeAttempts.delete(`${name}:${teammate.spawnId}`);
     // No close event will fire for an already-gone child, so this branch is
@@ -1082,21 +1204,25 @@ export async function shutdownTeammate(name: string): Promise<{ ok: true; body:
   return { ok: true, body: `Agent @${name} stopped.` };
 }
 
-async function handleTeammateClose(name: string, spawnId: string, result: WorkerProcessResult): Promise<void> {
+async function handleTeammateClose(name: string, spawnId: string, result: AgentProcessResult): Promise<void> {
   if (!runtimeStateFile) return;
-  const teammate = getTeammate(name);
+  const teammate = getAgent(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);
 
-  await finalizeWorktree(name);
-
   // Drain final reports before tearing down replay metadata so nothing
   // written before close is lost.
   drainTeammateOutboxes();
 
-  const released = releaseTasksOf(name, requested ? "Agent was stopped." : "Agent stopped unexpectedly.");
+  // A clean idle close with no outstanding result is a lifecycle fact, not a
+  // failed assignment. Keep it visible without starting another leader turn.
+  const cleanIdleClose = !crashed && teammate.status === "idle"
+    && !hasUnfinalizedReport(name) && !verificationFrozen(teammate)
+    && !pendingSubmissions.has(name) && !pendingResidentInputs.has(spawnId)
+    && !pendingDeliveries.has(name) && !hasUnreadPeerMail(teammate);
+  const released = failTasksHeldBy(name, requested ? "Agent was stopped." : "Agent stopped unexpectedly.");
   for (const task of released) {
     clearInconclusiveForHolding(task.id, teammate.spawnId);
     invalidateVerifyGate(task.id);
@@ -1106,9 +1232,10 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
   // A stopped teammate must not keep the poll loop or its queue alive.
   pendingSubmissions.delete(name);
   pendingDeliveries.delete(name);
+  residentSequences.delete(spawnId);
   idleNudgesSent.delete(`${name}:${teammate.spawnId}`);
   selfFinalizeAttempts.delete(`${name}:${teammate.spawnId}`);
-  updateTeammate(name, {
+  updateAgent(name, {
     status: "stopped",
     activeTool: undefined,
     error: requested ? undefined : closeErrorText(result, crashed),
@@ -1116,17 +1243,16 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
   clearWorkerRunEvents(name, teammate.spawnId);
   removeWorkerOutbox(requireStateFile(), name, teammate.spawnId);
 
-  if (requested) {
+  if (requested || (cleanIdleClose && released.length === 0)) {
     const summary = summarizeShutdown(name, released.length, result.exitCode, result.usage);
     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.
+    // Requested stops and clean idle closure need no additional leader turn.
   } else {
     deliverToLeader({ from: name, subject: "Agent stopped unexpectedly", body: crashDiagnostic(name, result, released) });
     const closeReport = {
-      teammate: name,
+      agent: name,
       spawnId: teammate.spawnId,
-      body: `@${name} stopped unexpectedly${released.length > 0 ? `; claimed task(s) ${released.map((t) => t.id).join(", ")} returned to the board` : ""}.`,
+      body: `@${name} stopped unexpectedly${released.length > 0 ? `; claimed task(s) ${released.map((t) => t.id).join(", ")} returned to the tasks` : ""}.`,
       origin: "harness" as const,
       harnessEvent: { type: "unexpected-stop", subject: `@${name} stopped unexpectedly` },
       finished: false,
@@ -1138,12 +1264,12 @@ async function handleTeammateClose(name: string, spawnId: string, result: Worker
   notifyChange();
 }
 
-function closeErrorText(result: WorkerProcessResult, crashed: boolean): string | undefined {
+function closeErrorText(result: AgentProcessResult, crashed: boolean): string | undefined {
   if (!crashed) return undefined;
   return `Closed unexpectedly (code ${result.exitCode ?? "unknown"}${result.signal ? `, signal ${result.signal}` : ""}).`;
 }
 
-function crashDiagnostic(name: string, result: WorkerProcessResult, released: Array<{ id: string }>): string {
+function crashDiagnostic(name: string, result: AgentProcessResult, released: Array<{ id: string }>): string {
   return [
     `Agent @${name} closed without a shutdown request.`,
     result.stderr?.trim() ? `stderr: ${result.stderr.trim()}` : undefined,
@@ -1156,7 +1282,7 @@ function summarizeShutdown(
   name: string,
   releasedCount: number,
   exitCode: number | null | undefined,
-  usage?: import("./types").WorkerUsage,
+  usage?: import("./types").AgentUsage,
 ): string {
   const lines = [`Agent @${name} stopped (exit code ${exitCode ?? "unknown"}).`];
   if (releasedCount > 0) lines.push(`Released claimed task(s): ${releasedCount}.`);
@@ -1164,78 +1290,12 @@ function summarizeShutdown(
   return lines.join("\n");
 }
 
-async function finalizeWorktree(name: string): Promise<void> {
-  const handle = liveWorktrees.get(name);
-  if (!handle || "error" in handle) {
-    liveWorktrees.delete(name);
-    return;
-  }
-  liveWorktrees.delete(name);
-  const captured = captureWorktreeDiff(handle);
-  // Cleanup commits any remaining work onto the kept branch before removing
-  // the directory: staging alone would die with the worktree.
-  const cleaned = cleanupWorktree(handle);
-  if (!captured.ok) {
-    // The branch survives cleanup, so nothing is lost; wake the leader with
-    // the recovery path because this requires a decision.
-    const body = `Capturing @${name}'s worktree diff failed (${captured.error}). The branch ${handle.branch} was kept; inspect it manually.`;
-    deliverToLeader({ from: name, subject: "Worktree diff capture failed", body });
-    sendUpdate({
-      teammate: name,
-      origin: "harness",
-      harnessEvent: { type: "worktree-capture-failed", subject: `@${name} worktree diff capture failed` },
-      body,
-      finished: false,
-    });
-    return;
-  }
-  const changed = captured.diff.patch.trim().length > 0;
-  deliverToLeader({
-    from: name,
-    subject: "Worktree diff captured",
-    body: changed
-      ? `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
-  // clean worktree carries no information and stays log-only.
-  if (changed) {
-    sendUpdate({
-      teammate: name,
-      spawnId: getTeammate(name)?.spawnId,
-      origin: "harness",
-      harnessEvent: { type: "worktree-changes", subject: `@${name} worktree changes captured` },
-      body: [
-        `Worktree changes captured for @${name} (${captured.diff.diffStat.trim() || "diff"}).`,
-        "",
-        truncated(captured.diff.patch),
-        "",
-        `Full diff: git diff ${handle.baseCommit}..${handle.branch}`,
-      ].join("\n"),
-      finished: false,
-    });
-  }
-  if (!cleaned.ok) {
-    const subject = cleaned.error?.includes("worktree left in place") ? "Worktree cleanup aborted" : "Worktree cleanup issue";
-    const body = `Cleaning up @${name}'s worktree reported problems (${cleaned.error ?? "unknown cleanup failure"}).`;
-    deliverToLeader({ from: name, subject, body });
-    sendUpdate({
-      teammate: name,
-      origin: "harness",
-      harnessEvent: { type: "worktree-cleanup-failed", subject: `@${name} worktree cleanup issue` },
-      body,
-      finished: false,
-    });
-  }
-}
-
 // ── Report outbox draining ────────────────────────────────────────
 
 /** Poll one batch per worker; explicit control drains its recipient's existing snapshot. */
 export function drainTeammateOutboxes(recipient?: string): void {
   const stateFile = requireStateFile();
-  for (const teammate of livingTeammates()) {
+  for (const teammate of livingAgents()) {
     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;
@@ -1259,7 +1319,7 @@ function deliverDiagnostic(from: string, detail: string): void {
   deliverToLeader({ from, subject: "Agent channel diagnostic", body: detail });
 }
 
-function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
+function applyOutboxRecord(teammate: Agent, record: unknown): boolean {
   if (!isWorkerEvent(record)) return false;
   if (record.worker !== teammate.name || record.spawnId !== teammate.spawnId) return false;
   const ids = getState().workerEventIds;
@@ -1275,9 +1335,9 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
     const taskId = teammate.currentTaskId;
     const task = taskId ? getTask(taskId) : undefined;
     if (teammate.assignment && taskId && task?.claimedBy === teammate.name
-      && (task.status === "claimed" || task.status === "superseded")) {
+      && (task.status === "in_progress" || isTaskReplaced(task))) {
       applySubmissionMarker({
-        taskId, worker: teammate.name, spawnId: teammate.spawnId, assignmentId: teammate.assignment.id,
+        taskId, participant: teammate.name, spawnId: teammate.spawnId, assignmentId: teammate.assignment.id,
         status, result: record.body, timestamp: record.timestamp ?? Date.now(),
       });
     } else {
@@ -1297,13 +1357,14 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
   }, { archived });
   // Informational events carry no Work acceptance authority.
   const report = {
-    teammate: teammate.name,
-    agent: teammate.agent,
+    agent: teammate.name,
+    role: teammate.role,
     spawnId: teammate.spawnId,
     body: record.body,
-    origin: "teammate" as const,
+    origin: "agent" as const,
     eventId: record.id,
     assignmentId: record.assignmentId,
+    ...(teammate.inputId ? { inputId: teammate.inputId } : {}),
     workId: teammate.workId,
     status: record.status,
     timestamp: record.timestamp ?? Date.now(),
@@ -1317,13 +1378,13 @@ function applyOutboxRecord(teammate: Teammate, record: unknown): boolean {
 // ── Peer inbox routing ────────────────────────────────────────────
 
 /**
- * Route new inbox messages. Idle teammates get the content queued for their
- * next wake-up; working teammates receive it immediately through their
+ * Route new inbox messages. Idle agents get the content queued for their
+ * next wake-up; working agents receive it immediately through their
  * control stream (falling back to queueing when the stream is unavailable).
  */
 export function routePeerInboxes(): void {
   const stateFile = requireStateFile();
-  for (const teammate of livingTeammates()) {
+  for (const teammate of livingAgents()) {
     if (pendingShutdowns.has(teammate.name)) continue;
     const inboxName = teammate.name;
     const inbox = inboxPath(stateFile, inboxName);
@@ -1355,6 +1416,32 @@ export function routePeerInboxes(): void {
   }
 }
 
+/** Inspect unread mail without routing it or changing delivery evidence. */
+function hasUnreadPeerMail(teammate: Agent): boolean {
+  const inbox = inboxPath(requireStateFile(), teammate.name);
+  let endOffset: number;
+  try {
+    endOffset = fs.statSync(inbox, { throwIfNoEntry: false })?.size ?? 0;
+  } catch {
+    // An unreadable inbox cannot establish that this child owes no input.
+    return true;
+  }
+  let offset = getPeerInboxOffset(teammate.name);
+  if (offset > endOffset) offset = 0;
+  while (offset < endOffset) {
+    const batch = readJsonlBatch(inbox, offset, endOffset);
+    if (batch.diagnostics.length || batch.nextOffset <= offset) return true;
+    for (const record of batch.records) {
+      const message = parseInboxMessage(record);
+      if (!message) return true;
+      if (!isPeerDelivered(teammate.name, message.id)
+        && (!message.toSpawnId || message.toSpawnId === teammate.spawnId)) return true;
+    }
+    offset = batch.nextOffset;
+  }
+  return false;
+}
+
 function parseInboxMessage(record: unknown): InboxMessage | undefined {
   if (!record || typeof record !== "object") return undefined;
   const candidate = record as Partial<InboxMessage>;
@@ -1364,42 +1451,47 @@ function parseInboxMessage(record: unknown): InboxMessage | undefined {
   return { ...candidate, timestamp: candidate.timestamp ?? Date.now() } as InboxMessage;
 }
 
-function submissionPending(teammate: Teammate): boolean {
+function submissionPending(teammate: Agent): boolean {
   const pending = pendingSubmissions.get(teammate.name);
-  if (pending?.spawnId === teammate.spawnId && pending.assignmentId === teammate.assignment?.id) return true;
+  if (pending?.spawnId === teammate.spawnId && pending.assignmentId === teammate.assignment?.id) return !pending.rejected;
   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;
+    && task?.status === "in_progress" && task.claimedBy === teammate.name;
 }
 
-function gateInFlight(teammate: Teammate): boolean {
+function gateInFlight(teammate: Agent): boolean {
   return teammate.currentTaskId !== undefined && verifyingTasks.has(teammate.currentTaskId);
 }
 
-function verificationFrozen(teammate: Teammate): boolean {
+function verificationFrozen(teammate: Agent): 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 {
+/** Deferred deliveries archived when an accepted result closed the Task they
+ *  were waiting behind. Leader-side, not on the task: a peer message is a
+ *  coordination record, and the task store states what must be done rather than what
+ *  was said about it. Bounded per Task because nothing ever reads the whole
+ *  archive. */
+const archivedDeliveries = new Map<string, Array<{ from: string; subject: string; body: string; timestamp: number }>>();
+
+function archiveDeferredDeliveries(teammate: Agent): 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();
+  const taskId = teammate.currentTaskId;
+  if (taskId) {
+    const archived = archivedDeliveries.get(taskId) ?? [];
+    archived.push(...deliveries.map(({ from, subject, body, timestamp }) => ({ from, subject, body, timestamp })));
+    archivedDeliveries.set(taskId, archived.slice(-20));
+    markTasksChanged();
   }
   for (const delivery of deliveries) setPeerDeliveryState(delivery.id, "routed");
-  markBoardChanged();
 }
 
-function dispatchInboxMessage(teammate: Teammate, message: InboxMessage): void {
+function dispatchInboxMessage(teammate: Agent, message: InboxMessage): void {
   if (verificationFrozen(teammate)) {
     setPeerDeliveryState(message.id, "queued");
     const queued = pendingDeliveries.get(teammate.name) ?? [];
@@ -1414,7 +1506,7 @@ function dispatchInboxMessage(teammate: Teammate, message: InboxMessage): void {
     || teammate.status === "starting"
     || isFreshAssignmentPending(teammate.name)
   )
-    ? sendWorkerFollowUp(teammate.name, `${marker}${formatDelivery([message])}`)
+    ? sendAgentFollowUp(teammate.name, `${marker}${formatDelivery([message])}`)
     : false;
   if (routed) {
     setPeerDeliveryState(message.id, "routed");
@@ -1427,6 +1519,115 @@ function dispatchInboxMessage(teammate: Teammate, message: InboxMessage): void {
   ensureLivePoll();
 }
 
+export type ResidentControlResult = { ok: true } | { ok: false; error: string };
+
+/** Policy check for a bounded input reservation. No task or sequence is created. */
+export function authorizeResidentInput(name: string, spawnId: string): ResidentControlResult {
+  let agent = currentHostedResident(name, spawnId);
+  if (!agent) return { ok: false, error: "The exact hosted child is unavailable." };
+  if (pendingShutdowns.has(name) || agent.leaderRequestedEnd) return { ok: false, error: "The hosted child is stopping." };
+  // Consume the predecessor while its settlement flag and input ID still belong
+  // to that sequence. The queue changes them only after this policy succeeds.
+  drainTeammateOutboxes(name);
+  agent = currentHostedResident(name, spawnId);
+  if (!agent) return { ok: false, error: "The exact hosted child changed during report delivery." };
+  if (pendingShutdowns.has(name) || agent.leaderRequestedEnd) return { ok: false, error: "The hosted child is stopping." };
+  if (isFreshAssignmentPending(name) || verificationFrozen(agent)) return { ok: false, error: "Task verification or assignment reset prevents input reservation." };
+  return { ok: true };
+}
+
+function currentHostedResident(name: string, spawnId: string): Agent | undefined {
+  const agent = getAgent(name);
+  return agent && agent.spawnId === spawnId && agent.status !== "stopped" && !agent.standalone ? agent : undefined;
+}
+
+/** Continue one idle incarnation without resetting its Pi session or spawning.
+ * A later independent input gets attempt-bound result authority before delivery;
+ * an unfinished current holding continues under its existing authority. */
+export async function sendResidentSequence(name: string, spawnId: string, input: string): Promise<ResidentControlResult> {
+  const agent = currentHostedResident(name, spawnId);
+  if (!agent) return { ok: false, error: `No living hosted session "${exactSessionRoute(name, spawnId)}".` };
+  if (!input.trim()) return { ok: false, error: "Send requires non-empty input." };
+  if (pendingShutdowns.has(name) || agent.leaderRequestedEnd) return { ok: false, error: `@${name} is stopping.` };
+  if (agent.status !== "idle" || pendingResidentInputs.has(spawnId) || isFreshAssignmentPending(name)) {
+    return { ok: false, error: `@${name} is not idle for new input; inspect or interrupt its active sequence.` };
+  }
+  drainTeammateOutboxes(name);
+  // Draining may synchronously start the final report's verification gate.
+  if (verificationFrozen(agent)) return { ok: false, error: `@${name}'s Task is awaiting verification or explicit recovery; input cannot bypass that authority.` };
+  const currentTask = agent.currentTaskId ? getTask(agent.currentTaskId) : undefined;
+  const continuing = agent.assignment && !agent.assignment.closed && currentTask?.status === "in_progress" && !isTaskReplaced(currentTask) && currentTask.claimedBy === name;
+  if (!continuing && currentTask && (currentTask.status === "in_progress" || isTaskReplaced(currentTask))) {
+    return { ok: false, error: `@${name} still retains Task authority; settle or recover it before independent input.` };
+  }
+  const previousReportEnded = agent.reportSequenceEnded;
+  const previousWorkId = agent.workId;
+  let newTaskId: string | undefined;
+  if (!continuing) {
+    const assignment: WorkerAssignment = { id: `direct:${randomUUID()}`, kind: "direct", resources: [] };
+    newTaskId = `work:${randomUUID()}`;
+    const bound = createBoundWork({ id: newTaskId, subject: messageTitle(input), description: input, holder: name, assignment });
+    if (!bound.ok) return { ok: false, error: bound.reason };
+    updateAgent(name, { workId: newTaskId });
+  }
+  const assignmentId = agent.assignment!.id;
+  const sequence = residentSequences.get(spawnId);
+  const deliverRole = sequence !== undefined && !sequence.roleDelivered;
+  const payload = `[agent-teams-assignment:${assignmentId}]\n` + (deliverRole
+    ? buildKickoffPrompt(name, agent.role, sequence.rolePrompt, input)
+    : input);
+  pendingResidentInputs.add(spawnId);
+  // Reserve synchronously so sibling sends cannot race the acknowledgement.
+  updateAgent(name, { status: "working", sequenceEnded: false, reportSequenceEnded: false, error: undefined, lastOutputAt: Date.now() });
+  publishStateSnapshot();
+  try {
+    const accepted = await deliverResidentPrompt(name, payload);
+    const current = currentHostedResident(name, spawnId);
+    if (!current) return { ok: false, error: "Resident exited or was replaced before input acknowledgement." };
+    if (!accepted) {
+      // A confirmed negative ack did not authorize a new turn. Do not undo
+      // evidence if this attempt already settled before the response arrived.
+      if (current.sequenceEnded !== true && current.assignment?.id === assignmentId) {
+        if (newTaskId && getTask(newTaskId)?.status === "in_progress") {
+          discardTask(newTaskId, name);
+          updateAgent(name, { workId: previousWorkId });
+        }
+        updateAgent(name, { status: "idle", sequenceEnded: true, reportSequenceEnded: previousReportEnded });
+      }
+      return { ok: false, error: `@${name} did not accept input; no new turn was confirmed.` };
+    }
+    if (sequence) sequence.roleDelivered = true;
+    return { ok: true };
+  } catch (error) {
+    // RPC timeout is uncertain: input may have begun. Retain the attempt and
+    // working reservation; retrying must not create a competing input turn.
+    const detail = error instanceof Error ? error.message : String(error);
+    if (currentHostedResident(name, spawnId)) updateAgent(name, { error: detail });
+    return { ok: false, error: detail };
+  } finally {
+    pendingResidentInputs.delete(spawnId);
+    if (runtimeStateFile) publishStateSnapshot();
+    notifyChange();
+  }
+}
+
+/** Native acknowledged steering stays in the current sequence and attempt. */
+export async function interruptResidentSequence(name: string, spawnId: string, input: string): Promise<ResidentControlResult> {
+  const agent = currentHostedResident(name, spawnId);
+  if (!agent) return { ok: false, error: `No living hosted session "${exactSessionRoute(name, spawnId)}".` };
+  if (!input.trim()) return { ok: false, error: "Interrupt requires non-empty input." };
+  if (agent.status === "idle") return { ok: false, error: `@${name} is idle; use send.` };
+  if (pendingShutdowns.has(name) || agent.leaderRequestedEnd) return { ok: false, error: `@${name} is stopping.` };
+  if (isFreshAssignmentPending(name) || verificationFrozen(agent)) return { ok: false, error: `@${name}'s attempt is resetting or awaiting verification; steering cannot bypass it.` };
+  try {
+    const accepted = await deliverResidentSteer(name, input);
+    if (!currentHostedResident(name, spawnId)) return { ok: false, error: "Resident exited or was replaced before steer acknowledgement." };
+    return accepted ? { ok: true } : { ok: false, error: `@${name} did not accept the steer; its sequence is unchanged.` };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 /** Route the leader's addressed agent_event through the same delivery path. */
 export type MessageRoutingOutcome = "steered" | "queued";
 
@@ -1439,7 +1640,7 @@ 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 teammate = getAgent(name);
   const assignmentId = teammate?.assignment?.id ?? teammate?.lastAssignment?.id;
   const mailbox = getState().leaderMailbox;
   for (let i = mailbox.length - 1; i >= 0; i--) {
@@ -1459,12 +1660,12 @@ export type AssignExistingWorkResult =
 /** 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());
+  const teammate = resolveExactSession(session, listAgents());
   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
+  if (task?.status === "in_progress" && task.claimedBy === owner
     && teammate.currentTaskId === workId && teammate.assignment && !teammate.assignment.closed) {
     return { ok: true, workId, owner, assignmentId: teammate.assignment.id };
   }
@@ -1475,9 +1676,9 @@ export function assignExistingWork(workId: string, session: string): AssignExist
   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 });
+  const claimed = bindTask(workId, owner, assignment, { from: ["pending"] });
+  if (!claimed.ok) return { ok: false, error: claimed.reason };
+  updateAgent(owner, { reportSequenceEnded: false });
   flushSnapshots();
   const prompt = buildFreshAssignmentPrompt(teammate, assignment.id, [
     `Work Item ${task.id}: ${task.subject}`,
@@ -1486,11 +1687,11 @@ export function assignExistingWork(workId: string, session: string): AssignExist
   ].filter(Boolean).join("\n\n"));
   void deliverFreshAssignment(owner, prompt).then((sent) => {
     if (sent) {
-      updateTeammate(owner, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
+      updateAgent(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.", false);
+    if (getAgent(owner)?.assignment?.id === assignment.id) {
+      revertUndeliveredTake(workId, owner, "Pi session reset failed before the assigned Work started.");
     }
     deliverDiagnostic(owner, "Pi session reset failed; the assigned Work was not delivered.");
   });
@@ -1504,45 +1705,14 @@ export type ReopenExistingWorkResult =
 /** 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;
+  const reopened = reopenTask(workId);
+  if (!reopened.ok) return { ok: false, error: reopened.reason };
   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, false);
-  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,
@@ -1550,7 +1720,7 @@ export function sendLeaderMessage(
   options?: { reopen?: boolean | "if-closed"; resources?: string[]; workId?: string },
 ): SendLeaderMessageResult {
   drainTeammateOutboxes(to);
-  const teammate = getTeammate(to);
+  const teammate = getAgent(to);
   if (!teammate || teammate.status === "stopped") return { ok: false, error: `No living teammate named "${to}".` };
   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.
@@ -1575,7 +1745,7 @@ export function sendLeaderMessage(
   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.` };
+    return { ok: false, error: `@${to} has no open assignment. Take pending work with task update status=in_progress, or move a completed task back with task update status=pending first.` };
   }
   const retryReleasedWork = selectedExistingWork?.status === "pending" && teammate.assignment === undefined;
   if (teammate.assignment?.kind === "direct" && teammate.assignment.closed && !reopen && !retryReleasedWork) {
@@ -1583,23 +1753,23 @@ export function sendLeaderMessage(
     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.` };
   }
-  // A board holder keeps its task after a terminal report. The leader must be
+  // A task set holder keeps its task after a terminal report. The leader must be
   // 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 && !reopen && !retryReleasedWork && !activeBoardHolder) {
+  const activeTaskHolder = teammate.assignment?.kind === "task" && !teammate.assignment.closed;
+  if (teammate.reportSequenceEnded && !reopen && !retryReleasedWork && !activeTaskHolder) {
     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 work action=reopen followed by work action=assign for another Work attempt.` };
+    return { ok: false, error: `@${to} already sent a terminal report. Move the task back with task update status=pending before another attempt.` };
   }
   const priorTerminalReport = teammate.reportSequenceEnded ? recordedTerminalReportBody(to) : undefined;
-  const boardParkKey = teammate.currentTaskId ? `${teammate.currentTaskId}:${teammate.spawnId}` : undefined;
+  const taskParkKey = teammate.currentTaskId ? `${teammate.currentTaskId}:${teammate.spawnId}` : undefined;
   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"
-      ? `work action=submit or be released/superseded`
+    const action = teammate.assignment.kind === "task"
+      ? `task complete, or be 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.` };
   }
@@ -1616,49 +1786,54 @@ export function sendLeaderMessage(
       resources,
     };
     if (reclaimingExistingWork) {
-      const reclaimed = reclaimDirectWork(
+      const reclaimed = bindTask(
         selectedWorkId ?? "",
         to,
         assignment,
-        retryReleasedWork ? "pending" : recoveringUnexpectedExecution ? "claimed" : "completed",
-        recoveringUnexpectedExecution,
+        {
+          from: [retryReleasedWork ? "pending" : recoveringUnexpectedExecution ? "in_progress" : "completed"],
+          // An unexpected execution left the previous holder's lease unreturned.
+          // Binding anyway is the point: the holder is gone, so waiting for a
+          // lease nobody will give back would strand the task.
+          allowHeldLease: recoveringUnexpectedExecution,
+        },
       );
-      if (!reclaimed.ok) return reclaimed;
+      if (!reclaimed.ok) return { ok: false, error: reclaimed.reason };
     } 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({
+        const bound = createBoundWork({
           id: selectedWorkId,
           subject: messageTitle(message),
           description: message,
           resources,
-          workerName: to,
+          holder: to,
           assignment,
         });
-        if (!created.ok) return created;
-        updateTeammate(to, { workId: selectedWorkId });
+        if (!bound.ok) return { ok: false, error: bound.reason };
+        updateAgent(to, { workId: selectedWorkId });
       } else {
-        assignTeammate(to, assignment, undefined);
+        assignAgent(to, assignment, undefined);
       }
     }
-    updateTeammate(to, { reportSequenceEnded: false });
+    updateAgent(to, { reportSequenceEnded: false });
   }
   // A successfully accepted leader message is the explicit direction that
-  // unblocks a twice-inconclusive board holding; rejected reopen does nothing.
-  if (boardParkKey) {
-    inconclusiveParks.delete(boardParkKey);
-    verifyFailureParks.delete(boardParkKey);
-    unexpectedExecutionParks.delete(boardParkKey);
+  // unblocks a twice-inconclusive tasks holding; rejected reopen does nothing.
+  if (taskParkKey) {
+    inconclusiveParks.delete(taskParkKey);
+    verifyFailureParks.delete(taskParkKey);
+    unexpectedExecutionParks.delete(taskParkKey);
   }
-  if (activeBoardHolder) updateTeammate(to, { reportSequenceEnded: false });
+  if (activeTaskHolder) updateAgent(to, { reportSequenceEnded: false });
   const envelope: InboxMessage = {
     id: randomUUID(),
     from: "leader",
     subject: messageTitle(message),
-    body: `${opensDirectAssignment || (activeBoardHolder && priorTerminalReport !== undefined) ? `[agent-teams-assignment:${teammate.assignment?.id ?? "none"}]\n` : ""}${message}`,
+    body: `${opensDirectAssignment || (activeTaskHolder && priorTerminalReport !== undefined) ? `[agent-teams-assignment:${teammate.assignment?.id ?? "none"}]\n` : ""}${message}`,
     timestamp: Date.now(),
     toSpawnId: teammate.spawnId,
   };
@@ -1666,22 +1841,22 @@ export function sendLeaderMessage(
   if (opensDirectAssignment) {
     void deliverFreshAssignment(teammate.name, formatDelivery([envelope])).then((sent) => {
       if (sent) {
-        updateTeammate(to, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
+        updateAgent(to, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
         return;
       }
-      const current = getTeammate(to);
+      const current = getAgent(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.", false);
+        revertUndeliveredTake(currentTaskId, to, "Pi session reset failed before the new Assignment Attempt started.");
       } else if (current?.assignment?.id === teammate.assignment?.id) {
-        assignTeammate(to, undefined, undefined);
+        assignAgent(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() });
+  const steered = sendAgentSteer(teammate.name, formatDelivery([envelope]));
+  if (steered) updateAgent(to, { status: "working", sequenceEnded: false, lastOutputAt: Date.now() });
   if (steered) return { ok: true, outcome: "steered", ...(priorTerminalReport ? { priorTerminalReport } : {}) };
   const queued = pendingDeliveries.get(teammate.name) ?? [];
   queued.unshift(envelope);
@@ -1722,13 +1897,13 @@ export function deliverFeedback(to: string, subject: string, body: string): void
 
 /** Apply claim markers, then submission markers (with verify gating). */
 export function processTaskIntents(): void {
-  const claims = claimsDir(boardDirectory());
-  const submissions = submissionsDir(boardDirectory());
+  const claims = claimsDir(taskDirectory());
+  const submissions = submissionsDir(taskDirectory());
   let guard = 0;
   while (guard++ < 64) {
     const { intent, diagnostic } = takeTaskIntent(claims);
     if (diagnostic) {
-      deliverToLeader({ from: "task-board", subject: "Task intent diagnostic", body: diagnostic });
+      deliverToLeader({ from: "tasks", subject: "Task intent diagnostic", body: diagnostic });
       continue;
     }
     if (!intent) break;
@@ -1738,7 +1913,7 @@ export function processTaskIntents(): void {
   while (guard++ < 64) {
     const { intent, diagnostic } = takeTaskIntent(submissions);
     if (diagnostic) {
-      deliverToLeader({ from: "task-board", subject: "Task intent diagnostic", body: diagnostic });
+      deliverToLeader({ from: "tasks", subject: "Task intent diagnostic", body: diagnostic });
       continue;
     }
     if (!intent) break;
@@ -1754,64 +1929,62 @@ function applyClaimMarker(intent: import("./types").TaskIntent): void {
     clearInconclusiveForHolding(intent.taskId, intent.spawnId);
     // A new holding must not inherit an in-flight gate from a previous one.
     invalidateVerifyGate(intent.taskId);
-    updateTeammate(intent.worker, { currentTaskId: intent.taskId });
-    const teammate = getTeammate(intent.worker);
+    updateAgent(intent.participant, { currentTaskId: intent.taskId });
+    const teammate = getAgent(intent.participant);
     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.",
+      "Complete this task with task action=complete outcome=success.",
     ].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.", false);
+      if (getAgent(teammate.name)?.assignment?.id === assignmentId) {
+        revertUndeliveredTake(task.id, teammate.name, "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.");
+  deliverFeedback(intent.participant, "Claim rejected", outcome.reason ?? "The task is no longer available.");
 }
 
 function applySubmissionMarker(intent: import("./types").TaskIntent): void {
   if (intent.status !== "completed" && intent.status !== "failed") {
-    deliverFeedback(intent.worker, "Submission rejected", `Task "${intent.taskId}" has an invalid submission status.`);
+    deliverFeedback(intent.participant, "Submission rejected", `Task "${intent.taskId}" has an invalid submission status.`);
     return;
   }
   const sender = findLivingTeammate(intent);
   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.`);
+  const pending = pendingSubmissions.get(intent.participant);
+  if (pending?.spawnId === intent.spawnId && pending.assignmentId === intent.assignmentId && !pending.rejected) return;
+  if (!task || (task.status !== "in_progress" && !isTaskReplaced(task)) || task.claimedBy !== intent.participant) {
+    deliverFeedback(intent.participant, "Submission rejected", `Task "${intent.taskId}" is not currently yours.`);
     return;
   }
-  if (task.status === "superseded") {
+  if (isTaskReplaced(task)) {
     if (intent.status !== "failed") {
-      deliverFeedback(intent.worker, "Submission rejected", `Task "${intent.taskId}" was superseded by "${task.supersededBy ?? "a replacement"}". Stop work and submit failed to acknowledge cancellation.`);
+      deliverFeedback(intent.participant, "Submission rejected", `Task "${intent.taskId}" was superseded by "${task.supersededBy ?? "a replacement"}". Stop work and submit failed to acknowledge cancellation.`);
       return;
     }
     if (sender.sequenceEnded === false) {
-      pendingSubmissions.set(intent.worker, { ...intent, assignmentId: sender.assignment.id, verify: undefined });
+      pendingSubmissions.set(intent.participant, { ...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) || unexpectedExecutionParks.has(parkKey))) {
+  if (intent.status === "completed" && (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";
+      : "two explicit verification failures";
     deliverFeedback(
-      intent.worker,
+      intent.participant,
       "Submission rejected while verification is parked",
       `Task "${intent.taskId}" has ${reason}. Wait for explicit Work release and reassignment before submitting another completed outcome.`,
     );
@@ -1819,16 +1992,16 @@ function applySubmissionMarker(intent: import("./types").TaskIntent): void {
   }
   if (intent.status === "completed" && verifyingTasks.has(intent.taskId)) {
     deliverFeedback(
-      intent.worker,
+      intent.participant,
       "Submission rejected while verification is running",
       `Task "${intent.taskId}" already has a completion review or verdict clarification in flight. Wait for it to pass, fail, or become inconclusive before submitting another completed outcome.`,
     );
     return;
   }
-  const verify = intent.status === "completed" ? task.verify ?? resolveAgent(sender.agent, leaderCwd)?.verify : undefined;
+  const verify = intent.status === "completed" ? task.verify ?? resolveAgent(sender.role, leaderCwd)?.verify : undefined;
   const assignmentId = sender.assignment?.id;
   if (!assignmentId) return;
-  if (sender.sequenceEnded === false) pendingSubmissions.set(intent.worker, { ...intent, assignmentId, verify });
+  if (sender.sequenceEnded === false) pendingSubmissions.set(intent.participant, { ...intent, assignmentId, verify });
   else beginVerifyOrComplete(intent, verify);
 }
 
@@ -1844,7 +2017,7 @@ export function reactToVerifyFailure(
 }
 
 function authorizeDirectRevision(intent: import("./types").TaskIntent, detail: string): boolean {
-  const teammate = getTeammate(intent.worker);
+  const teammate = getAgent(intent.participant);
   const task = getState().tasks[intent.taskId];
   if (!teammate || teammate.spawnId !== intent.spawnId || teammate.assignment?.kind !== "direct" || !task) return false;
   const assignment = {
@@ -1852,8 +2025,8 @@ function authorizeDirectRevision(intent: import("./types").TaskIntent, detail: s
     kind: "direct" as const,
     resources: task.resources,
   };
-  assignTeammate(intent.worker, assignment, intent.taskId);
-  updateTeammate(intent.worker, { reportSequenceEnded: false });
+  assignAgent(intent.participant, assignment, intent.taskId);
+  updateAgent(intent.participant, { 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.`,
@@ -1868,8 +2041,8 @@ function authorizeDirectRevision(intent: import("./types").TaskIntent, detail: s
   );
   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.", false);
+    if (getAgent(teammate.name)?.assignment?.id === assignment.id) {
+      revertUndeliveredTake(intent.taskId, teammate.name, "Pi session reset failed before the verification revision started.");
     }
     deliverDiagnostic(teammate.name, "Pi session reset failed; the verification revision was not delivered.");
   });
@@ -1879,7 +2052,7 @@ function authorizeDirectRevision(intent: import("./types").TaskIntent, detail: s
 function beginVerifyOrComplete(intent: import("./types").TaskIntent, verify: string | undefined): void {
   const task = getState().tasks[intent.taskId];
   if (!task) return;
-  if (task.status === "superseded") {
+  if (isTaskReplaced(task)) {
     if (intent.status === "failed") releaseSupersededHolding(intent);
     return;
   }
@@ -1896,14 +2069,14 @@ 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();
-  const assignmentId = getTeammate(intent.worker)?.assignment?.id;
+  const assignmentId = getAgent(intent.participant)?.assignment?.id;
   if (!assignmentId) return;
-  verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, assignmentId, submissionId, token });
+  verifyingTasks.set(intent.taskId, { worker: intent.participant, spawnId: intent.spawnId, assignmentId, submissionId, token });
   const input: VerifyReviewInput = {
     verify,
     taskSubject: task.subject,
     workerResult: intent.result ?? "",
-    cwd: getTeammate(intent.worker)?.cwd || leaderCwd,
+    cwd: leaderCwd,
   };
   runVerifyGate(intent, task.subject, submissionId, token, input);
 }
@@ -1922,17 +2095,17 @@ function resolveGateOutcome(
   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
+  const holder = getAgent(intent.participant);
+  const stillHolds = current?.status === "in_progress"
+    && current.claimedBy === intent.participant
     && holder?.spawnId === intent.spawnId
     && holder.assignment?.id === active.assignmentId
-    && !pendingShutdowns.has(intent.worker);
+    && !pendingShutdowns.has(intent.participant);
   if (!stillHolds) return;
   if (outcome.kind === "pass") {
     inconclusiveVerifications.delete(submissionId);
     archiveDeferredDeliveries(holder);
-    finishCompletion(intent);
+    finishCompletion(intent, "pass");
   } else if (outcome.kind === "inconclusive") {
     const detail = outcome.detail ?? "(reviewer omitted a machine-readable verdict)";
     requestVerifyVerdict(intent, subject, submissionId, detail);
@@ -1943,36 +2116,54 @@ function resolveGateOutcome(
     verifyFailures.set(key, reaction);
     const detail = outcome.detail ?? "(no review output)";
     if (reaction.count >= VERIFY_FAILURE_ESCALATE_AFTER) {
-      // An unfixable gate parks the task with its holder instead of
-      // looping: no further resubmit invitations, one leader escalation.
-      verifyFailureParks.set(`${intent.taskId}:${intent.spawnId}`, { worker: intent.worker, spawnId: intent.spawnId });
+      // An unfixable gate stops the loop. It used to park the task with its
+      // holder, which left a runtime state only a leader-side release action could
+      // clear, and that action no longer exists.
+      //
+      // So it becomes what it factually is: the attempt ran and did not deliver
+      // an accepted result. The task returns to pending under a recovery hold, and
+      // whoever retries has to say what changed — which is the only thing that
+      // could possibly make a third attempt worth running.
+      const parked = completeTaskWithOutcome(
+        intent.taskId,
+        intent.participant,
+        "failed",
+        `The completion gate failed ${reaction.count} consecutive times: ${detail}`,
+      );
+      if (parked.ok) {
+        verifyFailureParks.delete(`${intent.taskId}:${intent.spawnId}`);
+        clearInconclusiveForHolding(intent.taskId, intent.spawnId);
+        freeAgentFromTask(intent.participant, intent.taskId);
+        rearmTaskNotice(intent.taskId);
+        publishStateSnapshot();
+      }
       if (reaction.escalateToLeader) {
         notifyTaskOutcome(subject, `verify failed ${reaction.count} times for ${intent.taskId}: manual attention needed`, detail);
-        // The holder is parked and will not narrate further; the parked task
-        // reaches the leader through the delivery channel itself.
+        // The holder is out of the task, so the leader is the only route left; the
+        // task itself is now pending and will not be retried unattended.
         sendUpdate({
-          teammate: "task-board",
+          agent: "tasks",
           origin: "harness",
           harnessEvent: { type: "verify-escalation", subject: `Verify gate failed · ${subject}` },
-          body: `Verify gate for "${subject}" (${intent.taskId}) failed ${reaction.count} consecutive times.\n\n${detail}\n\nThe task stays claimed by @${intent.worker}; decide how to proceed.`,
+          body: `Verify gate for "${subject}" (${intent.taskId}) failed ${reaction.count} consecutive times.\n\n${detail}\n\nThe attempt is recorded as not delivered and the task is pending under a recovery hold. It will not be retried until somebody takes it with a stated reason.`,
           finished: false,
         });
       }
       deliverFeedback(
-        intent.worker,
+        intent.participant,
         `Verify still failing for ${intent.taskId}`,
-        [`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"),
+        [`The completion gate for "${subject}" failed again (${reaction.count} consecutive failures).`, detail, "This attempt is recorded as not delivered, so the task is pending under a recovery hold. Retrying requires a stated reason describing what changed; ordinary messages do not authorize another submission."].join("\n"),
       );
     } else {
       const directRevision = authorizeDirectRevision(intent, detail);
       if (!directRevision) {
         deliverFeedback(
-          intent.worker,
+          intent.participant,
           `Verify failed for ${intent.taskId}`,
           [
             `The completion gate for "${subject}" failed.`,
             detail,
-            "Fix the issues and resubmit with work action=submit.",
+            "Fix the issues and redeliver with task action=complete outcome=success.",
           ].join("\n"),
         );
       }
@@ -1995,30 +2186,52 @@ function requestVerifyVerdict(
     const task = getState().tasks[intent.taskId];
     if (!task) return;
     const token = randomUUID();
-    const assignmentId = getTeammate(intent.worker)?.assignment?.id;
+    const assignmentId = getAgent(intent.participant)?.assignment?.id;
     if (!assignmentId) return;
-    verifyingTasks.set(intent.taskId, { worker: intent.worker, spawnId: intent.spawnId, assignmentId, submissionId, token });
+    verifyingTasks.set(intent.taskId, { worker: intent.participant, 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>.`,
+      verify: `${task.verify ?? resolveAgent(getAgent(intent.participant)?.role ?? "", 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,
+      cwd: leaderCwd,
     };
     runVerifyGate(intent, subject, submissionId, token, input);
     return;
   }
-  inconclusiveParks.set(`${intent.taskId}:${intent.spawnId}`, { worker: intent.worker, spawnId: intent.spawnId });
-  notifyTaskOutcome(subject, `verify inconclusive for ${intent.taskId}: manual verdict needed`, detail);
+  // The park used to be a distinct state: the task stayed in progress, held, with
+  // the runtime refusing further submissions, and a leader-side action was the only
+  // way out. That action no longer exists, and inventing a runtime state nothing
+  // can clear is worse than using the one that can.
+  //
+  // So an inconclusive verdict is recorded as what it is — the attempt did not
+  // deliver an accepted result — and the task returns to pending under a recovery
+  // hold. Any participant may then take it with a stated reason, and the hold's
+  // purpose is exactly this: one inconclusive reviewer must not be retried
+  // unattended by whichever participant happens to be idle.
+  inconclusiveParks.delete(`${intent.taskId}:${intent.spawnId}`);
+  const parked = completeTaskWithOutcome(
+    intent.taskId,
+    intent.participant,
+    "failed",
+    `Verification was inconclusive twice for ${intent.taskId}: ${detail}`,
+  );
+  if (!parked.ok) return;
+  clearInconclusiveForHolding(intent.taskId, intent.spawnId);
+  invalidateVerifyGate(intent.taskId);
+  freeAgentFromTask(intent.participant, intent.taskId);
+  rearmTaskNotice(intent.taskId);
+  publishStateSnapshot();
+  notifyTaskOutcome(subject, `verify inconclusive for ${intent.taskId}: a stated reason is needed to retry`, detail);
   deliverFeedback(
-    intent.worker,
+    intent.participant,
     `Verification inconclusive for ${intent.taskId}`,
-    `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}`,
+    `The reviewer twice omitted a machine-readable verdict, so this attempt did not deliver an accepted result. The task is pending under a recovery hold. Take it again with a stated reason, or change the task's verification.\n\n${detail}`,
   );
   sendUpdate({
-    teammate: "task-board",
+    agent: "tasks",
     origin: "harness",
     harnessEvent: { type: "verify-inconclusive", subject: `Verify verdict missing · ${subject}` },
-    body: `Verification for "${subject}" (${intent.taskId}) was inconclusive twice. It remains claimed by @${intent.worker} without counting as a verify failure.\n\n${detail}`,
+    body: `Verification for "${subject}" (${intent.taskId}) was inconclusive twice, so the attempt is recorded as not delivered and the task is pending under a recovery hold.\n\n${detail}`,
     finished: false,
   });
 }
@@ -2038,41 +2251,58 @@ function clearInconclusiveForHolding(taskId: string, spawnId: string): void {
   verifyFailures.delete(holding);
 }
 
-function finishCompletion(intent: import("./types").TaskIntent): void {
+function finishCompletion(intent: import("./types").TaskIntent, reviewVerdict?: "pass"): void {
   const task = getState().tasks[intent.taskId];
   if (!task) return;
-  const teammate = getTeammate(intent.worker);
+  const teammate = getAgent(intent.participant);
   const assignmentId = teammate?.assignment?.id;
   if (!teammate || !assignmentId) return;
+  // Only the bound independent review supplies a verdict; worker fields are not authority.
+  const completed = completeTaskWithOutcome(intent.taskId, intent.participant, "success", intent.result,
+    reviewVerdict ? { verdict: reviewVerdict } : {});
+  if (!completed.ok) {
+    rejectCompletion(intent, assignmentId, completed.reason);
+    return;
+  }
   retirePendingSubmission(intent);
-  const completed = completeTask(intent.taskId, intent.result);
-  if (!completed) return;
   clearInconclusiveForHolding(intent.taskId, intent.spawnId);
-  freeTeammateFromTask(intent.worker, intent.taskId);
+  freeAgentFromTask(intent.participant, intent.taskId);
   announceWorkOutcome(intent, teammate, assignmentId);
 }
 
+function rejectCompletion(intent: import("./types").TaskIntent, assignmentId: string, reason: string): void {
+  // Retain the submission freeze, but never retry refused evidence automatically.
+  // A new explicit submission may replace it without releasing the holding.
+  const pending = pendingSubmissions.get(intent.participant);
+  if (pending?.spawnId === intent.spawnId && pending.assignmentId === assignmentId) pending.rejected = true;
+  else pendingSubmissions.set(intent.participant, { ...intent, assignmentId, verify: undefined, rejected: true });
+  deliverFeedback(intent.participant, "Submission rejected", reason);
+}
+
 function retirePendingSubmission(intent: import("./types").TaskIntent): void {
-  const pending = pendingSubmissions.get(intent.worker);
+  const pending = pendingSubmissions.get(intent.participant);
   if (pending?.spawnId === intent.spawnId && pending.assignmentId === intent.assignmentId) {
-    pendingSubmissions.delete(intent.worker);
+    pendingSubmissions.delete(intent.participant);
   }
 }
 
 function releaseSupersededHolding(intent: import("./types").TaskIntent): void {
   retirePendingSubmission(intent);
-  releaseTask(intent.taskId, intent.result?.trim() || "Superseded task cancellation acknowledged.", false);
+  acknowledgeSupersession(intent.taskId, intent.participant, 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 teammate = getAgent(intent.participant);
   const assignmentId = teammate?.assignment?.id;
   if (!teammate || !assignmentId) return;
+  const released = completeTaskWithOutcome(intent.taskId, intent.participant, "failed", intent.result?.trim() || "Agent reported failure.");
+  if (!released.ok) {
+    rejectCompletion(intent, assignmentId, released.reason);
+    return;
+  }
   retirePendingSubmission(intent);
-  const released = releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.", true);
-  if (!released) return;
   clearInconclusiveForHolding(intent.taskId, intent.spawnId);
   invalidateVerifyGate(intent.taskId);
   // Failure is evidence for deliberate recovery, not a fresh work offer to
@@ -2080,18 +2310,19 @@ function finishFailure(intent: import("./types").TaskIntent): void {
   announceWorkOutcome(intent, teammate, assignmentId);
 }
 
-function announceWorkOutcome(intent: import("./types").TaskIntent, teammate: Teammate, assignmentId: string): void {
-  updateTeammate(intent.worker, { reportSequenceEnded: true });
+function announceWorkOutcome(intent: import("./types").TaskIntent, agent: Agent, assignmentId: string): void {
+  updateAgent(intent.participant, { reportSequenceEnded: true });
   const eventId = randomUUID();
   const status = intent.status === "failed" ? "failed" : "completed";
   const report: LeaderReport = {
-    teammate: intent.worker, agent: teammate.agent, spawnId: intent.spawnId,
+    agent: intent.participant, role: agent.role, spawnId: intent.spawnId,
     workId: intent.taskId, assignmentId, status, finished: true,
-    origin: "teammate", eventId, timestamp: intent.timestamp,
+    ...(agent.inputId ? { inputId: agent.inputId } : {}),
+    origin: "agent", eventId, timestamp: intent.timestamp,
     body: intent.result || "(no result summary submitted)",
   };
   receiveWorkerMessage({
-    id: eventId, type: "message", worker: intent.worker, spawnId: intent.spawnId,
+    id: eventId, type: "message", worker: intent.participant, spawnId: intent.spawnId,
     assignmentId, status, body: report.body, timestamp: report.timestamp,
   });
   sendUpdate(report);
@@ -2106,12 +2337,11 @@ export const VERIFY_VERDICT_FAIL = "VERDICT: FAIL";
 export interface VerifyReviewInput {
   /** The acceptance-gate prompt (task-level or agent-role default). */
   verify: string;
-  /** Board subject of the gated task. */
+  /** Tasks subject of the gated task. */
   taskSubject: string;
   /** The claimer's own result summary; evidence, never trusted alone. */
   workerResult: string;
-  /** Working directory to review: the holder's worktree root when isolated,
-   *  else the leader cwd — the reviewer must inspect the claimed work's tree. */
+  /** Original project working tree to review, never the private scratch cwd. */
   cwd: string;
   /** Aborted when the holding's authority is invalidated (release, stop, new
    *  claim, supersession, or resumed owner execution), so an orphaned reviewer
@@ -2128,7 +2358,7 @@ export type VerifyReviewOutcome =
 export function buildVerifyReviewPrompt(input: VerifyReviewInput): string {
   const result = input.workerResult.trim().slice(0, 4000);
   return [
-    "You are a fresh completion-gate reviewer for one teammate task on a shared board.",
+    "You are a fresh completion-gate reviewer for one participant task in the shared task set.",
     `Task subject: ${input.taskSubject}`,
     result ? `The claimer's result summary:\n${result}` : "The claimer provided no result summary.",
     "Independently verify the work against the acceptance gate below using your tools; do not trust the summary alone. Do not modify any files.",
@@ -2207,21 +2437,21 @@ export function setVerifyGateRunner(runner: ((input: VerifyReviewInput) => Promi
   verifyGateRunner = runner ?? runVerifyReview;
 }
 
-function freeTeammateFromTask(workerName: string, taskId: string): void {
-  const teammate = getTeammate(workerName);
-  if (teammate?.currentTaskId === taskId) updateTeammate(workerName, { currentTaskId: undefined });
+function freeAgentFromTask(agentName: string, taskId: string): void {
+  const entry = getAgent(agentName);
+  if (entry?.currentTaskId === taskId) updateAgent(agentName, { currentTaskId: undefined });
 }
 
 function notifyTaskOutcome(subject: string, headline: string, body: string): void {
   deliverToLeader({
-    from: "task-board",
+    from: "tasks",
     subject: `Task ${headline}: ${subject}`,
     body: body || "(no result summary submitted)",
   });
 }
 
-function findLivingTeammate(intent: import("./types").TaskIntent): Teammate | undefined {
-  const teammate = getTeammate(intent.worker);
+function findLivingTeammate(intent: import("./types").TaskIntent): Agent | undefined {
+  const teammate = getAgent(intent.participant);
   return teammate && teammate.status !== "stopped" && teammate.spawnId === intent.spawnId ? teammate : undefined;
 }
 
@@ -2236,7 +2466,7 @@ export function freshClaimableTasks<T extends { id: string }>(
   return tasks.filter((task) => !noticed.has(task.id));
 }
 
-/** Retain only noticed ids that are still claimable, so a long board's history
+/** Retain only noticed ids that are still claimable, so a long tasks's history
  *  can never evict a live one and resurrect an old wake-up. */
 export function retainLiveNoticedIds(noticedIds: readonly string[], claimableIds: ReadonlySet<string>): string[] {
   return noticedIds.filter((id) => claimableIds.has(id));
@@ -2244,37 +2474,37 @@ export function retainLiveNoticedIds(noticedIds: readonly string[], claimableIds
 
 function markTasksNoticed(name: string, taskIds: string[]): void {
   if (taskIds.length === 0) return;
-  const teammate = getTeammate(name);
+  const teammate = getAgent(name);
   if (!teammate) return;
   const live = retainLiveNoticedIds(teammate.noticedTaskIds ?? [], new Set(claimableTasks().map((task) => task.id)));
   const merged = [...live, ...taskIds];
   while (merged.length > MAX_NOTICED_TASK_IDS) merged.shift();
-  updateTeammate(name, { noticedTaskIds: merged });
+  updateAgent(name, { noticedTaskIds: merged });
 }
 
 /** A released task becomes noticeable again for every living teammate. */
 function rearmTaskNotice(taskId: string): void {
-  for (const teammate of livingTeammates()) {
+  for (const teammate of livingAgents()) {
     if (teammate.noticedTaskIds?.includes(taskId)) {
-      updateTeammate(teammate.name, { noticedTaskIds: teammate.noticedTaskIds.filter((id) => id !== taskId) });
+      updateAgent(teammate.name, { noticedTaskIds: teammate.noticedTaskIds.filter((id) => id !== taskId) });
     }
   }
 }
 
 /**
  * Compose one wake-up prompt per idle teammate from queued inbox deliveries
- * plus a board notice covering only claimable work that teammate has never
+ * plus a task set notice covering only claimable work that teammate has never
  * been shown. Teammates with nothing new are never woken.
  */
 export function wakeIdleTeammates(immediateTaskId?: string): string[] {
   const notified: string[] = [];
-  for (const teammate of idleTeammates()) {
-    if (pendingShutdowns.has(teammate.name) || verificationFrozen(teammate)) continue;
+  for (const teammate of idleAgents()) {
+    if (pendingShutdowns.has(teammate.name) || pendingResidentInputs.has(teammate.spawnId) || 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.
-    const boardEligible = teammate.assignment === undefined;
-    const fresh = boardEligible
+    // A terminal direct assignment stays closed until explicit reopen; a task set
+    // holder must submit rather than drifting into more task work.
+    const taskEligible = teammate.assignment === undefined;
+    const fresh = taskEligible
       ? freshClaimableTasks(teammate.noticedTaskIds, claimableTasks().filter((task) => !activeAssignmentConflict(task.resources, teammate.name)))
       : [];
     const immediateNotice = immediateTaskId !== undefined && fresh.some((task) => task.id === immediateTaskId);
@@ -2287,21 +2517,23 @@ export function wakeIdleTeammates(immediateTaskId?: string): string[] {
           ...fresh.filter((task) => task.id !== immediateTaskId),
         ];
     const noticed = prioritized.slice(0, WAKE_NOTICE_TASK_LIMIT);
-    const role = !teammate.assignment && teammate.turns === 0
-      ? `=== ROLE PROMPT (${teammate.agent}) ===\n${resolveAgent(teammate.agent, leaderCwd)?.prompt ?? ""}\n\n`
+    const sequence = residentSequences.get(teammate.spawnId);
+    const role = !teammate.assignment && (sequence ? !sequence.roleDelivered : teammate.turns === 0)
+      ? `=== ROLE PROMPT (${teammate.role}) ===\n${sequence?.rolePrompt ?? resolveAgent(teammate.role, 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;
+    if (sequence) sequence.roleDelivered = true;
     for (const delivery of deliveries) setPeerDeliveryState(delivery.id, "routed");
     notified.push(teammate.name);
     pendingDeliveries.delete(teammate.name);
     if (dueNotice) markTasksNoticed(teammate.name, noticed.map((task) => task.id));
     // A delivered prompt is fresh activity: restart the silence clock so a
     // long-idle teammate is never insta-flagged as stalled on wake.
-    updateTeammate(teammate.name, {
+    updateAgent(teammate.name, {
       status: "working",
       sequenceEnded: false,
-      // A generic peer/harness/board wake-up never opens a terminal direct
+      // A generic peer/harness/tasks wake-up never opens a terminal direct
       // assignment. Only an explicit Work assignment owns that transition.
       ...(teammate.assignment?.kind === "direct" && teammate.assignment.closed
         ? {}
@@ -2313,7 +2545,7 @@ export function wakeIdleTeammates(immediateTaskId?: string): string[] {
   return notified;
 }
 
-function noticeDue(teammate: Teammate): boolean {
+function noticeDue(teammate: Agent): boolean {
   return teammate.lastNoticeAt === undefined || Date.now() - teammate.lastNoticeAt >= NOTICE_PACE_MS;
 }
 
@@ -2328,7 +2560,7 @@ 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 work action=list for details and work action=claim to take one if appropriate for your role.`);
+    sections.push(`=== TASK NOTICE ===\nUnclaimed tasks: ${listed}\nUse task action=list for details and task update status=in_progress to take one if it suits your role.`);
   }
   if (sections.length === 0) return "";
   const leader = deliveries.find((message) => message.from === "leader" && message.body.startsWith("[agent-teams-assignment:"));
@@ -2342,39 +2574,37 @@ function formatDelivery(messages: InboxMessage[]): string {
   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 ────────────────────────────
+// ── Tasks helpers shared with tools.ts ────────────────────────────
+
+/** A refusal that reached the coordinator's own task surface keeps the store's
+ *  shape — code, detail, reason — rather than being flattened to a sentence, so
+ *  a coordinator can still branch on why a creation was refused. It is re-exported
+ *  because `createCoordinatedTask` is the coordinator's task entry point. */
+export type { TaskRefusalResult };
 
-export interface BoardTaskCreationResult {
+export interface TaskCreationResult {
   ok: true;
   id: string;
   notifiedTeammates: string[];
-  livingTeammates: number;
+  livingAgents: number;
   claimable: boolean;
   resourceBlocked: boolean;
   supersededTaskIds: string[];
 }
 
-/** Create a task and synchronously offer it to currently-idle teammates.
+/** Run the coordination side effects of superseding work.
  *
- * The normal poll loop still handles later dependency unlocks and queued mail,
- * but task creation is a user-visible boundary: an idle teammate should not
- * have to wait for a future timer tick before it can see newly-created work.
+ * Split out because the tasks transition itself belongs to @fradser/pi-tasks
+ * now, and this package hears about it on `pi-tasks:task-created` rather than
+ * performing it. A superseded holder keeps its assignment and resource lease
+ * until it acknowledges cancellation, so its feedback has to be routable before
+ * the replacement is announced.
+ *
+ * @returns the ids that were superseded, for the caller's report.
  */
-export function createBoardTask(input: {
-  subject: string;
-  description?: string;
-  dependsOn?: string[];
-  verify?: string;
-  resources?: string[];
-  supersedes?: string[];
-}): BoardTaskCreationResult | { ok: false; error: string } {
-  const created = createTask(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; cancellation is lifecycle control, so it
-    // must unpark the holder before its feedback can be routed.
-    const holder = task.claimedBy ? getTeammate(task.claimedBy) : undefined;
+export function settleSupersededWork(replaced: readonly Task[], replacementId: string): string[] {
+  for (const task of replaced) {
+    const holder = task.claimedBy ? getAgent(task.claimedBy) : undefined;
     invalidateVerifyGate(task.id);
     if (holder) unexpectedExecutionParks.delete(`${task.id}:${holder.spawnId}`);
     for (const [name, pending] of pendingSubmissions) {
@@ -2388,7 +2618,7 @@ export function createBoardTask(input: {
       deliverFeedback(
         holder.name,
         `Task superseded: ${task.id}`,
-        `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.`,
+        `Task "${task.id}" was superseded by "${replacementId}". Stop work immediately and acknowledge the cancellation with task complete outcome="failed" so its resources are released.`,
       );
     }
     for (const key of [...verifyFailures.keys()]) {
@@ -2399,6 +2629,67 @@ export function createBoardTask(input: {
     }
     rearmTaskNotice(task.id);
   }
+  return replaced.map((task) => task.id);
+}
+
+/** A task was created by @fradser/pi-tasks' own `task` tool.
+ *
+ * This is the whole of the leader's response to a task set transition: settle what
+ * the supersession displaced, offer the new task to idle residents, and refresh
+ * what the console shows. It arrives as an event rather than a call so
+ * `@fradser/pi-tasks` never has to know a resident exists, and so a standalone
+ * tasks with nobody listening still works.
+ */
+export function onTaskCreated(input: { id: string; replaced?: string[] }): void {
+  const replaced = (input.replaced ?? []).map((id) => getState().tasks[id]).filter(Boolean) as Task[];
+  if (replaced.length > 0) settleSupersededWork(replaced, input.id);
+  publishStateSnapshot();
+  // Creation is a user-visible boundary: an idle resident should not have to
+  // wait for a later poll tick to see new work.
+  wakeIdleTeammates(input.id);
+  publishStateSnapshot();
+  notifyChange();
+}
+
+/** A task was taken.
+ *
+ * This is where a re-take invalidates a verification gate left over from the
+ * previous attempt. That work used to sit in the leader-side release action, which
+ * no longer exists: a task returns to pending because a participant failed it,
+ * because the runtime reverted a half-finished start, or because its holder
+ * exited. Whichever route brought it back, a reviewer still judging the old
+ * candidate must not be able to accept the new one.
+ */
+export function onTaskTaken(input: { id: string }): void {
+  invalidateVerifyGate(input.id);
+  rearmTaskNotice(input.id);
+  onTaskChanged();
+}
+
+/** Any other tasks transition: no resident needs waking, but the snapshot and the
+ *  console both show the tasks, so both are refreshed. */
+export function onTaskChanged(): void {
+  publishStateSnapshot();
+  notifyChange();
+}
+
+/** Create a task and synchronously offer it to currently-idle agents.
+ *
+ * The normal poll loop still handles later dependency unlocks and queued mail,
+ * but task creation is a user-visible boundary: an idle teammate should not
+ * have to wait for a future timer tick before it can see newly-created work.
+ */
+export function createCoordinatedTask(input: {
+  subject: string;
+  description?: string;
+  dependsOn?: string[];
+  verify?: string;
+  resources?: string[];
+  supersedes?: string[];
+}): TaskCreationResult | TaskRefusalResult {
+  const created = createTask(input);
+  if (!created.ok) return created;
+  const supersededTaskIds = settleSupersededWork(created.superseded, created.task.id);
   publishStateSnapshot();
   const resourceBlocked = activeAssignmentConflict(created.task.resources) !== undefined;
   const notifiedTeammates = wakeIdleTeammates(created.task.id);
@@ -2408,26 +2699,26 @@ export function createBoardTask(input: {
     ok: true,
     id: created.task.id,
     notifiedTeammates,
-    livingTeammates: livingTeammates().length,
+    livingAgents: livingAgents().length,
     claimable: claimableTasks().some((task) => task.id === created.task.id) && !resourceBlocked,
     resourceBlocked,
-    supersededTaskIds: created.superseded.map((task) => task.id),
+    supersededTaskIds,
   };
 }
 
 /** Worker-side submission through an exclusive-create marker file. */
 export function attemptSubmission(
-  workerName: string,
+  agentName: string,
   spawnId: string,
   taskId: string,
   status: "completed" | "failed",
   result?: string,
 ): boolean {
-  return createTaskIntent(submissionsDir(boardDirectory()), taskId, {
+  return createTaskIntent(submissionsDir(taskDirectory()), taskId, {
     taskId,
-    worker: workerName,
+    participant: agentName,
     spawnId,
-    assignmentId: getTeammate(workerName)?.assignment?.id,
+    assignmentId: getAgent(agentName)?.assignment?.id,
     status,
     result,
     timestamp: Date.now(),