@fradser/pi-agent-teams 0.9.2 → 0.10.0

package/.memory/MEMORY.md

@@ -4,3 +4,4 @@
 
 - `team-centric-design.md` — Agent Teams current architecture: named resident RPC teammates, shared task board with atomic self-claim, direct P2P inboxes, verify-gated completion, harness-driven wake-ups. Supersedes the deleted run-centric DAG design.
 - `follow-up-queue.md` — Teammate report steering handoff: hand reports immediately to Pi's steering channel without an internal serialized follow-up queue; delivers at safe tool boundaries.
+- `attempt-bound-authority.md` — Worker communication, claims, and submissions bind to the started Assignment Attempt; failed or interrupted Work is recovery-held until an explicit leader assignment, and retired nonterminal reports leave the provider projection while staying in history.

package/.memory/attempt-bound-authority.md

@@ -0,0 +1,19 @@
+---
+name: attempt-bound-authority
+description: Worker communication and submissions bind to the started Assignment Attempt; failed Work is recovery-held instead of silently re-claimable
+type: project
+---
+
+## Why
+
+A real session exposed four coupled lifecycle defects. After a worker was superseded or stopped, its cancelled attempts kept emitting cancellation acknowledgements into a settled assignment; the `work` tool was hidden for a retained superseded holder, so it could not acknowledge cancellation at all and its resource lease stayed stranded. Turns that had started under one Assignment Attempt adopted a newly assigned `assignmentId` from the live roster, so an old turn could send or submit as replacement Work. A failed Work Item returned to the board as plainly `pending`, so idle residents were repeatedly re-delegated the same doomed work while the leader treated the failure as already handled. Nonterminal reports from retired attempts also kept acting as current leader instructions.
+
+## How to apply
+
+- `packages/agent-teams/src/worker.ts` binds a turn at `message_start`: `assignmentId`/`taskId` come from the delivered assignment marker, and `authorize()` rejects any call whose roster entry names a different attempt, Work Item, or incarnation. Reads match on `spawnId` as well as name so a replacement resident cannot lend authority.
+- A bound, living, same-spawn roster entry with no assignment clears the binding for that turn: a retried attempt must not dead-end an ordinary peer/board wake.
+- `send`, `queueWorkClaim`, and `queueWorkSubmission` all pass the same authority; a terminal outcome or closed assignment rejects further sends, claims, and submissions. A retained superseded holder keeps exactly one failed cancellation acknowledgement.
+- `packages/agent-teams/src/state.ts` marks failed, crash-released, or stop-released Work `recoveryRequired`, which excludes it from `claimableTasks()` and wake notices; only an explicit leader `work assign` clears it. A harness start failure that never reached the worker stays ordinarily claimable.
+- `packages/agent-teams/src/index.ts` keeps a retired attempt's nonterminal report in session history but removes it from the provider projection, because Pi cannot retract an already-queued steer.
+- Keep BDD coverage in `features/worker-attempt-lifecycle.feature`, `features/session-history-regressions.feature`, and `features/historical-report-delivery.feature`; regressions live in `tests/test_worker_attempt_lifecycle.py`, `tests/test_session_history_regressions.py`, and `tests/test_historical_report_delivery.py`.
+- Guidance states the contract in two sentences; `tests/test_prompt_budget.py` ceilings for `tmActiveLeader`/`tmWorker` were raised deliberately with that change.

package/README.md

@@ -51,6 +51,13 @@ assignment-only scheduling mode.
 `work` owns Work lifecycle. Leaders create/list/assign/release/reopen completed
 Work/supersede; Workers list/claim/submit/release their current Work.
 
+Failed, interrupted, or crash-released Work returns to the board as
+`pending/recovery-required`: the evidence stays available for inspection, and the
+harness deliberately excludes it from autonomous claim notices. Only an explicit
+leader `work assign` opens the next attempt, so a transient failure is never
+silently retried by whichever resident happens to be idle. A retained superseded
+holder keeps `work` disclosed for exactly one failed cancellation acknowledgement.
+
 ```ts
 work({ action: "create", subject: "Fix storage", resources: ["firmware/storage"] })
 work({ action: "assign", id: "fix-storage", target: { session: "session:worker-...:spawn-..." } })
@@ -89,6 +96,10 @@ After delegation, continue independent work or end the turn: results resume the
 session automatically. Use `agent inspect` for deliberate diagnosis, not repeated
 polling or sleep loops. `agent_event` never creates or retries Work; messaging a
 completed assignment returns its recorded result without waking the worker.
+Worker communication and submissions are bound to the Assignment Attempt that
+started the turn, so an old turn cannot report or submit as replacement Work, and
+nonterminal coordination from a retired attempt stays in session history as
+evidence without acting as a current instruction.
 Recovery reuses the existing Work ID. Request explicit `work release` and await
 authoritative release before `work assign` to the chosen exact session; a queued
 release is not yet released authority. Do not create competing recovery Work via

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fradser/pi-agent-teams",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Multi-agent team system for Pi — resident teammates, shared task board, and peer-to-peer messaging",
   "keywords": [
     "pi-package",

package/src/guidance.ts

@@ -45,7 +45,10 @@ claim or submission is not ownership or completion; the harness is authoritative
 
 Use \`agent_event\` only for \`inform\` or \`request\` communication with the
 leader or an exact peer session. It arrives at the next safe tool boundary or wakes an idle leader. It cannot complete, release, reopen, or reassign
-Work. The runtime delivers ordinary final answers automatically for the current Work
+Work. Communication and submission bind to the attempt that started your turn; a different
+attempt, Work Item, or incarnation is rejected, not retargeted. After a submission or
+cancellation acknowledgement, end the turn.
+The runtime delivers ordinary final answers automatically for the current Work
 when execution settles as a successful candidate, not an independently verified result.
 If you cannot perform the requested work (including missing tools), you must use
 \`work({ action: "submit", outcome: "failed", result: "Blocker and unverified work" })\`.
@@ -116,6 +119,9 @@ For recovery, keep the existing Work ID: request explicit \`work release\` and a
 
 Observe stalled sessions in \`/agent-teams\`. The harness never reclaims, restarts, or replaces a teammate. Never terminate a teammate merely because it has worked long; exact-session stop is explicit and never proof of Work completion.
 
+Failed or interrupted Work returns as \`pending/recovery-required\` and waits for an explicit
+\`work assign\`; retired attempts' reports stop instructing you.
+
 ### Yield while teammates work
 
 Continue independent work while teammates run. If none remains, end the turn; results resume the session automatically.

package/src/index.ts

@@ -11,7 +11,7 @@ import { buildIdleLeaderGuidance, buildTeamLeaderGuidance, WORKER_GUIDANCE } fro
 import { clearSessionAgents } from "./agents.ts";
 import { getConfirmedStopTime, initTeamMachine, markTeammateFinished, removeRuntimeDir, shutdownTeamMachine, syncLeaderContext, teardownTeammates } from "./team-machine.ts";
 import { cleanupExpiredStateDirs } from "./statefile.ts";
-import { livingTeammates, listTasks, resetState } from "./state.ts";
+import { getTask, getTeammate, livingTeammates, listTasks, resetState } from "./state.ts";
 import { ensureTeamWidget, refreshTeamUI, stopUiTimers } from "./ui.ts";
 import { registerLeaderTools, registerTeamCommand } from "./tools.ts";
 import { registerWorkerCapabilities, workerBinding } from "./worker.ts";
@@ -34,6 +34,45 @@ let leaderPi: ExtensionAPI | undefined;
 let leaderCtx: ExtensionContext | undefined;
 
 export const TEAMMATE_FINISHED_ENTRY_TYPE = "agent-teams-teammate-finished";
+/** Audit entry for a retired attempt's nonterminal report. The evidence stays in the
+ * session while the context projection stops treating it as a current instruction;
+ * without a renderer the retained entry would be invisible in the transcript. */
+export const TEAMMATE_HISTORICAL_ENTRY_TYPE = "agent-teams-historical-report";
+
+/** One entry per retained report, so a re-delivered report cannot multiply its own
+ * audit trail. Bounded the same way the finish announcements are. */
+const HISTORICAL_ENTRY_LIMIT = 512;
+const retainedHistoricalReports = new Set<string>();
+function rememberRetainedReport(report: LeaderReport): boolean {
+  const key = [
+    report.teammate ?? report.agent ?? "",
+    report.spawnId ?? "",
+    report.eventId ?? "",
+    report.timestamp ?? 0,
+  ].join(":");
+  if (retainedHistoricalReports.has(key)) return false;
+  retainedHistoricalReports.add(key);
+  while (retainedHistoricalReports.size > HISTORICAL_ENTRY_LIMIT) {
+    const oldest = retainedHistoricalReports.values().next().value;
+    if (oldest === undefined) break;
+    retainedHistoricalReports.delete(oldest);
+  }
+  return true;
+}
+
+/** Accepted outcomes remain evidence even after their process exits. Only
+ * nonterminal coordination loses current authority when its attempt retires; the
+ * source report stays in the session as the visible audit trail. */
+function isHistoricalReport(report: LeaderReport): boolean {
+  if (report.origin === "harness" || report.harnessEvent || report.finished
+    || report.status === "completed" || report.status === "failed") return false;
+  if (!report.spawnId || !report.teammate) return false;
+  const worker = getTeammate(report.teammate);
+  if (!worker || worker.spawnId !== report.spawnId || worker.status === "stopped") return true;
+  if (report.assignmentId !== worker.assignment?.id || worker.assignment?.closed || worker.reportSequenceEnded) return true;
+  const task = worker.currentTaskId ? getTask(worker.currentTaskId) : undefined;
+  return task?.status === "superseded" || task?.status === "completed";
+}
 
 function sendLeaderReport(report: LeaderReport): void {
   try {
@@ -85,6 +124,11 @@ export default function (pi: ExtensionAPI) {
     const name = data?.teammate ?? data?.agent ?? "teammate";
     return new Text(theme.fg("success", `Assignment for @${name} finished.`), 0, 0);
   });
+  pi.registerEntryRenderer(TEAMMATE_HISTORICAL_ENTRY_TYPE, (entry, _options, theme) => {
+    const data = entry.data as { teammate?: string; agent?: string } | undefined;
+    const name = data?.teammate ?? data?.agent ?? "teammate";
+    return new Text(theme.fg("dim", `Historical report from @${name} retained for audit; it no longer instructs.`), 0, 0);
+  });
   pi.registerMessageRenderer(TEAMMATE_HARNESS_MESSAGE_TYPE, (message, { expanded }, theme) => {
     const report = extractHarnessReport(message.details);
     if (!report) return new Text(String(message.content), 0, 0);
@@ -144,6 +188,27 @@ export default function (pi: ExtensionAPI) {
   registerLeaderTools(pi);
   registerTeamCommand(pi);
 
+  // Pi cannot retract one already-queued steer. The persisted record stays for
+  // audit, and this projection keeps a retired attempt's nonterminal text from
+  // acting as a current instruction. Deliberate trade-off: while such a record
+  // exists the projection is recomputed per request, so a session that retires a
+  // report pays a prompt/tool replay each turn. Correctness wins over cache
+  // warmth here; the alternative needs an SDK API to rewrite a stored message.
+  pi.on("context", (event) => {
+    let changed = false;
+    const messages = event.messages.flatMap((message) => {
+      if (message.role !== "custom" || message.customType !== TEAMMATE_REPORT_MESSAGE_TYPE) return [message];
+      const reports = extractReports(message.details);
+      if (reports.length === 0) return [message];
+      const current = reports.filter((report) => !isHistoricalReport(report));
+      if (current.length === reports.length) return [message];
+      changed = true;
+      return current.length === 0 ? [] : [{ ...message, content: formatReports(current),
+        details: current.length === 1 ? current[0] : { reports: current } }];
+    });
+    return changed ? { messages } : undefined;
+  });
+
   pi.on("message_start", (event) => {
     if (event.message.role !== "custom" || event.message.customType !== TEAMMATE_REPORT_MESSAGE_TYPE) return;
     const deliveredAt = Date.now();
@@ -160,6 +225,26 @@ export default function (pi: ExtensionAPI) {
     ));
     if (reports.length === 0) return;
     for (const report of reports) {
+      // A retired attempt's nonterminal report keeps its evidence in the session but must
+      // stop instructing the leader. The context projection already excludes it from
+      // future requests; this entry is what keeps the retained evidence visible rather
+      // than silently dropped, and is appended once per report at the delivery seam.
+      if (isHistoricalReport(report)) {
+        if (rememberRetainedReport(report)) {
+          pi.appendEntry(TEAMMATE_HISTORICAL_ENTRY_TYPE, {
+            teammate: report.teammate ?? report.agent,
+            agent: report.agent,
+            spawnId: report.spawnId,
+            assignmentId: report.assignmentId,
+            workId: report.workId,
+            eventId: report.eventId,
+            status: report.status,
+            timestamp: report.timestamp,
+            body: report.body,
+          });
+        }
+        continue;
+      }
       if (!markTeammateFinished(report)) continue;
       pi.appendEntry(TEAMMATE_FINISHED_ENTRY_TYPE, {
         teammate: report.teammate ?? report.agent,

package/src/state.ts

@@ -527,7 +527,7 @@ export function pendingTasks(): BoardTask[] {
 }
 
 export function claimableTasks(): BoardTask[] {
-  return pendingTasks().filter(taskDependenciesMet);
+  return pendingTasks().filter((task) => !task.recoveryRequired && taskDependenciesMet(task));
 }
 
 export function taskDependenciesMet(task: BoardTask): boolean {
@@ -602,6 +602,7 @@ export function reclaimDirectWork(
   task.claimedBy = workerName;
   task.result = undefined;
   task.errorMessage = undefined;
+  task.recoveryRequired = undefined;
   task.completedAt = undefined;
   task.updatedAt = Date.now();
   boardRevisionCounter++;
@@ -613,7 +614,7 @@ export function reclaimDirectWork(
 export function setTaskClaimed(taskId: string, workerName: string): BoardTask | undefined {
   const task = state.tasks[taskId];
   const teammate = getTeammate(workerName);
-  if (!task || !teammate || task.status !== "pending" || !taskDependenciesMet(task)) return undefined;
+  if (!task || !teammate || task.status !== "pending" || task.recoveryRequired || !taskDependenciesMet(task)) return undefined;
   if (teammate.assignment) return undefined;
   if (activeAssignmentConflict(task.resources, workerName)) return undefined;
   task.status = "claimed";
@@ -626,7 +627,12 @@ export function setTaskClaimed(taskId: string, workerName: string): BoardTask |
 }
 
 /** Release a claimed task back to pending. A superseded holder instead
- * acknowledges cancellation: the task stays superseded but frees resources. */
+ * acknowledges cancellation: the task stays superseded but frees resources.
+ * `recoveryRequired` marks an attempt that ran and did not succeed (failure,
+ * crash, or stop), so it waits for a deliberate Leader assignment instead of
+ * being re-offered. A harness start failure that happened before the attempt
+ * reached the worker stays ordinarily claimable; a deliberate Leader release
+ * passes `false` for the same reason. */
 export function claimedDependents(workId: string): BoardTask[] {
   const reverse = new Map<string, string[]>();
   for (const task of Object.values(state.tasks)) {
@@ -661,6 +667,7 @@ export function reopenCompletedWork(workId: string): { ok: true; task: BoardTask
   task.result = undefined;
   task.deferredMessages = undefined;
   task.errorMessage = undefined;
+  task.recoveryRequired = undefined;
   task.completedAt = undefined;
   task.updatedAt = Date.now();
   boardRevisionCounter++;
@@ -668,12 +675,13 @@ export function reopenCompletedWork(workId: string): { ok: true; task: BoardTask
   return { ok: true, task };
 }
 
-export function releaseTask(taskId: string, errorMessage?: string): BoardTask | undefined {
+export function releaseTask(taskId: string, errorMessage: string | undefined, recoveryRequired: boolean): BoardTask | undefined {
   const task = state.tasks[taskId];
   if (!task || (task.status !== "claimed" && task.status !== "superseded")) return undefined;
   const holder = task.claimedBy;
   if (task.status === "claimed") task.status = "pending";
   task.claimedBy = undefined;
+  task.recoveryRequired = task.status === "pending" && recoveryRequired ? true : undefined;
   if (errorMessage !== undefined) task.errorMessage = errorMessage;
   task.updatedAt = Date.now();
   boardRevisionCounter++;
@@ -690,6 +698,7 @@ export function completeTask(taskId: string, result?: string): BoardTask | undef
   task.claimedBy = undefined;
   task.result = result;
   task.errorMessage = undefined;
+  task.recoveryRequired = undefined;
   task.completedAt = Date.now();
   task.updatedAt = Date.now();
   boardRevisionCounter++;
@@ -703,7 +712,7 @@ export function releaseTasksOf(workerName: string, reason: string): BoardTask[]
   const released: BoardTask[] = [];
   for (const task of listTasks()) {
     if ((task.status === "claimed" || task.status === "superseded") && task.claimedBy === workerName) {
-      releaseTask(task.id, reason);
+      releaseTask(task.id, reason, true);
       released.push(task);
     }
   }
@@ -724,6 +733,7 @@ export function applyClaimIntent(intent: TaskIntent): { applied: boolean; reason
   }
   if (task.status === "claimed") return { applied: false, reason: `task "${intent.taskId}" is already claimed` };
   if (task.status === "completed" || task.status === "superseded") return { applied: false, reason: `task "${intent.taskId}" is ${task.status}` };
+  if (task.recoveryRequired) return { applied: false, reason: `task "${intent.taskId}" requires explicit leader Work assignment after failure` };
   if (!taskDependenciesMet(task)) return { applied: false, reason: `task "${intent.taskId}" has unmet dependencies` };
   const conflict = activeAssignmentConflict(task.resources, intent.worker);
   if (conflict) return { applied: false, reason: `resource conflict with @${conflict.name}'s ${conflict.assignment?.kind} assignment "${conflict.assignment?.id}"` };
@@ -752,7 +762,7 @@ export function applySubmissionIntent(intent: TaskIntent): { ok: boolean; error?
     return { ok: false, error: `task "${intent.taskId}" was superseded by "${task.supersededBy ?? "a replacement"}"; submit failed to acknowledge cancellation` };
   }
   if (intent.status === "failed") {
-    releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.");
+    releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.", true);
     return { ok: true };
   }
   completeTask(intent.taskId, intent.result?.trim() || undefined);
@@ -774,6 +784,7 @@ export function loadBoard(tasks: Record<string, BoardTask>): number {
       ...task,
       resources: normalizeResources(task.resources),
       status: task.status === "claimed" ? "pending" : task.status,
+      recoveryRequired: task.status === "claimed" ? true : task.recoveryRequired,
       // Runtime workers and assignments die with the session. Superseded work
       // remains visible for audit but cannot retain a dead holder/resource lock.
       claimedBy: orphanedHolding ? undefined : task.claimedBy,

package/src/team-machine.ts

@@ -701,7 +701,7 @@ export function spawnTeammate(input: {
     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}`);
+      if (input.existingWorkId) releaseTask(input.existingWorkId, `Agent failed to start: ${error.message}`, false);
       failSpawn(input.name, error.message, input.existingWorkId);
     },
     onExit: (result) => {
@@ -710,7 +710,7 @@ export function spawnTeammate(input: {
     },
   });
   if ("error" in started) {
-    if (input.existingWorkId) releaseTask(input.existingWorkId, `Agent failed to start: ${started.error}`);
+    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);
     failSpawn(input.name, started.error, input.existingWorkId);
     return { ok: false, error: started.error };
@@ -1490,7 +1490,7 @@ export function assignExistingWork(workId: string, session: string): AssignExist
       return;
     }
     if (getTeammate(owner)?.assignment?.id === assignment.id) {
-      releaseTask(workId, "Pi session reset failed before the assigned Work started.");
+      releaseTask(workId, "Pi session reset failed before the assigned Work started.", false);
     }
     deliverDiagnostic(owner, "Pi session reset failed; the assigned Work was not delivered.");
   });
@@ -1535,7 +1535,7 @@ export function releaseExistingWork(workId: string, reason: string): ReleaseExis
     // residual window is reported instead of being silently implied safe.
     holderStillRunning = holder.status === "working" ? holder.name : undefined;
   }
-  const released = releaseTask(workId, reason);
+  const released = releaseTask(workId, reason, false);
   if (!released) return { ok: false, error: `Work Item "${workId}" could not be released.` };
   rearmTaskNotice(workId);
   publishStateSnapshot();
@@ -1672,7 +1672,7 @@ export function sendLeaderMessage(
       const current = getTeammate(to);
       const currentTaskId = current?.currentTaskId;
       if (current?.assignment?.id === teammate.assignment?.id && currentTaskId) {
-        releaseTask(currentTaskId, "Pi session reset failed before the new Assignment Attempt started.");
+        releaseTask(currentTaskId, "Pi session reset failed before the new Assignment Attempt started.", false);
       } else if (current?.assignment?.id === teammate.assignment?.id) {
         assignTeammate(to, undefined, undefined);
       }
@@ -1768,7 +1768,7 @@ function applyClaimMarker(intent: import("./types").TaskIntent): void {
     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.");
+        releaseTask(task.id, "Pi session reset failed before the claimed Assignment Attempt started.", false);
       }
       deliverDiagnostic(teammate.name, "Pi session reset failed; the claimed Assignment Attempt was not delivered.");
     });
@@ -1869,7 +1869,7 @@ 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.");
+      releaseTask(intent.taskId, "Pi session reset failed before the verification revision started.", false);
     }
     deliverDiagnostic(teammate.name, "Pi session reset failed; the verification revision was not delivered.");
   });
@@ -2061,7 +2061,7 @@ function retirePendingSubmission(intent: import("./types").TaskIntent): void {
 
 function releaseSupersededHolding(intent: import("./types").TaskIntent): void {
   retirePendingSubmission(intent);
-  releaseTask(intent.taskId, intent.result?.trim() || "Superseded task cancellation acknowledged.");
+  releaseTask(intent.taskId, intent.result?.trim() || "Superseded task cancellation acknowledged.", false);
   clearInconclusiveForHolding(intent.taskId, intent.spawnId);
   invalidateVerifyGate(intent.taskId);
 }
@@ -2071,11 +2071,12 @@ function finishFailure(intent: import("./types").TaskIntent): void {
   const assignmentId = teammate?.assignment?.id;
   if (!teammate || !assignmentId) return;
   retirePendingSubmission(intent);
-  const released = releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.");
+  const released = releaseTask(intent.taskId, intent.result?.trim() || "Agent reported failure.", true);
   if (!released) return;
   clearInconclusiveForHolding(intent.taskId, intent.spawnId);
   invalidateVerifyGate(intent.taskId);
-  rearmTaskNotice(intent.taskId);
+  // Failure is evidence for deliberate recovery, not a fresh work offer to
+  // every idle resident. Explicit work.assign starts the next attempt.
   announceWorkOutcome(intent, teammate, assignmentId);
 }
 

package/src/types.ts

@@ -116,6 +116,9 @@ export interface BoardTask {
   /** Deferred mail archived when an accepted result closes its Work Item. */
   deferredMessages?: Array<{ from: string; subject: string; body: string; timestamp: number }>;
   errorMessage?: string;
+  /** Failed/interrupted Work stays pending for inspection but cannot be
+   * autonomously claimed until the Leader deliberately authorizes recovery. */
+  recoveryRequired?: boolean;
   createdAt: number;
   updatedAt: number;
   completedAt?: number;
@@ -260,6 +263,10 @@ function mergeBranchSubSchemas(pool: any[]): any {
   return { anyOf: pool };
 }
 
+/** The root also declares `type: "object"`. A schema that carries `properties`
+ * without an explicit object type is rejected by Google's GenerateContent API
+ * ("parameters.properties: only allowed for OBJECT type"), which the Gemini
+ * routes reach through their provider translators. */
 function actionUnion<T extends TObject[]>(branches: [...T], options?: Record<string, unknown>): TUnion<T> {
   const pools: Record<string, any[]> = {};
   for (const branch of branches) {
@@ -273,7 +280,7 @@ function actionUnion<T extends TObject[]>(branches: [...T], options?: Record<str
   }
   const properties: Record<string, any> = {};
   for (const [key, pool] of Object.entries(pools)) properties[key] = mergeBranchSubSchemas(pool);
-  return Type.Union(branches, { ...options, properties } as never) as TUnion<T>;
+  return Type.Union(branches, { type: "object", ...options, properties } as never) as TUnion<T>;
 }
 
 /** Tolerate harnesses that deliver object or array parameters as JSON strings. */

package/src/worker.ts

@@ -44,8 +44,12 @@ function createWorkerToolDisclosure(pi: ExtensionAPI): WorkerToolDisclosure {
         ? readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)
         : undefined;
       const assignment = rosterEntry?.assignment;
-      if (assignment && !assignment.closed) state = "claimed";
-      else if (!assignment && prompt.includes("=== BOARD NOTICE ===")) state = "notice";
+      // A superseded holder still owns cancellation authority and must be
+      // able to acknowledge it; hiding work here strands its resource lease.
+      if (binding && rosterEntry && rosterEntry.spawnId === binding.spawnId
+        && rosterEntry.status !== "stopped" && assignment) {
+        state = "claimed";
+      } else if (!assignment && prompt.includes("=== BOARD NOTICE ===")) state = "notice";
       else state = "none";
       apply();
     },
@@ -97,7 +101,7 @@ function dependenciesMet(task: BoardTask, tasks: Map<string, BoardTask>): boolea
 function taskCounts(tasks: BoardTask[], byId: Map<string, BoardTask>): string {
   const counts = { pending: 0, claimed: 0, completed: 0, superseded: 0 };
   for (const task of tasks) counts[task.status] += 1;
-  const claimable = tasks.filter((task) => task.status === "pending" && dependenciesMet(task, byId)).length;
+  const claimable = tasks.filter((task) => task.status === "pending" && !task.recoveryRequired && dependenciesMet(task, byId)).length;
   return `tasks=${tasks.length} · pending=${counts.pending} (${claimable} claimable) · claimed=${counts.claimed} · completed=${counts.completed} · superseded=${counts.superseded}`;
 }
 
@@ -121,7 +125,7 @@ function claimRejection(binding: WorkerBinding, task: BoardTask): string | undef
 }
 
 function taskStatusLabel(task: BoardTask, tasks: Map<string, BoardTask>): string {
-  if (task.status === "pending") return dependenciesMet(task, tasks) ? "pending/claimable" : "pending/blocked";
+  if (task.status === "pending") return task.recoveryRequired ? "pending/recovery-required" : dependenciesMet(task, tasks) ? "pending/claimable" : "pending/blocked";
   return task.status;
 }
 
@@ -176,30 +180,43 @@ function automaticResultBody(binding: WorkerBinding, assignmentId: string, body:
 
 function createWorkerReports(pi: ExtensionAPI) {
   const initial = workerBinding();
-  const initialAssignment = initial ? readRoster(initial.rosterFile).find((entry) => entry.name === initial.worker)?.assignment : undefined;
+  const initialSelf = initial ? readRoster(initial.rosterFile).find((entry) => entry.name === initial.worker && entry.spawnId === initial.spawnId) : undefined;
+  const initialAssignment = initialSelf?.assignment;
   let assignmentId = initialAssignment?.id;
+  let taskId = initialSelf?.currentTaskId;
   let reportClosed = initialAssignment?.closed === true;
+  let terminalOutcome: "completed" | "failed" | undefined;
   let pending: { binding: WorkerBinding; assignmentId: string; timestamp: number; awaitingFinal?: boolean; outcome?: AutomaticResult } | undefined;
   const finalizedMessages = new WeakSet<AssistantResponse>();
   const currentAssignment = (binding: WorkerBinding) => {
-    const self = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker);
+    const self = readRoster(binding.rosterFile)
+      .find((entry) => entry.name === binding.worker && entry.spawnId === binding.spawnId);
     const assignment = self?.assignment;
     return !reportClosed && self?.spawnId === binding.spawnId && self.status !== "stopped"
       && assignment && assignment.id === assignmentId && !assignment.closed ? assignment : undefined;
   };
-  const close = () => {
+  const close = (outcome: "completed" | "failed") => {
     reportClosed = true;
+    terminalOutcome = outcome;
     pending = undefined;
   };
-  const reportAssignment = (binding: WorkerBinding) => {
-    const current = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)?.assignment;
-    if (current?.kind === "board" && current.id !== assignmentId) {
-      assignmentId = current.id;
-      reportClosed = false;
-      pending = undefined;
+  const authorize = (binding: WorkerBinding, cancellation = false) => {
+    const sameBinding = initial && binding.worker === initial.worker && binding.spawnId === initial.spawnId
+      && binding.outbox === initial.outbox && binding.rosterFile === initial.rosterFile;
+    const self = readRoster(binding.rosterFile)
+      .find((entry) => entry.name === binding.worker && entry.spawnId === binding.spawnId);
+    if (!sameBinding || !self || self.status === "stopped") {
+      throw new Error("Work authority rejected: this is not the bound living worker incarnation.");
     }
-    if (reportClosed) throw new Error("Leader report rejected: this assignment already has a terminal report. Wait for an explicit leader assignment.");
-    return assignmentId;
+    if (self.assignment?.id !== assignmentId || (taskId !== undefined && self.currentTaskId !== taskId)) {
+      throw new Error("Work authority rejected: this turn belongs to a different assignment. Wait for its fresh assignment marker.");
+    }
+    const cancelled = cancellation && assignmentId && self.currentTaskId
+      && (self.assignment?.closed || loadBoardTasks(binding).some((task) => task.id === self.currentTaskId && task.status === "superseded"));
+    if ((reportClosed || self.assignment?.closed) && !(cancelled && terminalOutcome !== "failed")) {
+      throw new Error("Leader report rejected: this assignment already has a terminal report or is closed. Stop; no repeated acknowledgment is required.");
+    }
+    return { assignmentId, taskId: taskId ?? self.currentTaskId };
   };
   pi.on("message_start", ({ message }) => {
     const binding = workerBinding();
@@ -208,12 +225,27 @@ function createWorkerReports(pi: ExtensionAPI) {
       const content = message.content;
       const text = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
       const marker = /^\[agent-teams-assignment:([^\n]+)\]\n/.exec(text);
-      const current = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)?.assignment;
+      const self = readRoster(binding.rosterFile)
+        .find((entry) => entry.name === binding.worker && entry.spawnId === binding.spawnId);
+      const current = self?.assignment;
       if (marker) {
         const id = marker[1] === "none" ? undefined : marker[1];
         if (id !== current?.id) return;
-        if (id !== assignmentId || current?.kind === "board") reportClosed = current?.closed === true;
+        if (id !== assignmentId) {
+          reportClosed = current?.closed === true;
+          terminalOutcome = undefined;
+        }
         assignmentId = id;
+        taskId = self?.currentTaskId;
+        pending = undefined;
+      } else if (!current) {
+        // The harness retired this attempt without a replacement marker: this is a
+        // fresh unassigned turn (peer mail, board notice, ordinary discussion).
+        // Holding the previous terminal state here would dead-end the worker.
+        assignmentId = undefined;
+        taskId = undefined;
+        reportClosed = false;
+        terminalOutcome = undefined;
         pending = undefined;
       }
       const assignment = currentAssignment(binding);
@@ -249,17 +281,19 @@ function createWorkerReports(pi: ExtensionAPI) {
       assignmentId: pending.assignmentId, timestamp: Date.now(), status: result.status,
       body: automaticResultBody(binding, pending.assignmentId, result.body),
     });
-    close();
+    close(result.status);
   });
   return {
     close,
+    authorize,
     send(binding: WorkerBinding, body: string, status: import("./types.ts").WorkerReportEvent["status"]) {
+      const authority = authorize(binding, status === "failed");
       appendWorkerEvent(binding.outbox, {
-        assignmentId: reportAssignment(binding), id: randomUUID(), type: "message",
+        assignmentId: authority.assignmentId, id: randomUUID(), type: "message",
         worker: binding.worker, spawnId: binding.spawnId, body, status, timestamp: Date.now(),
       });
       const isTerminal = status === "completed" || status === "failed";
-      if (isTerminal) close();
+      if (isTerminal) close(status);
       return isTerminal;
     },
     reset() { pending = undefined; },
@@ -287,9 +321,10 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
     async execute(_toolCallId, params) {
       const binding = workerBinding();
       if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
+      const authority = reports.authorize(binding);
       if (!params.to || params.to === LEADER_RECIPIENT) {
         appendWorkerEvent(binding.outbox, {
-          assignmentId: readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)?.assignment?.id, id: randomUUID(), type: "message", worker: binding.worker, spawnId: binding.spawnId,
+          assignmentId: authority.assignmentId, id: randomUUID(), type: "message", worker: binding.worker, spawnId: binding.spawnId,
           body: params.message, status: params.intent ?? "inform", timestamp: Date.now(),
         });
         return {
@@ -318,6 +353,9 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
   async function queueWorkClaim(id: string | undefined, presentation: "board" | "work") {
     const binding = workerBinding();
     if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
+    // Claims pass the same attempt authority as sends and submissions: a closed or
+    // terminal attempt must not queue new board work even when work is re-disclosed.
+    reports.authorize(binding);
     const label = presentation === "work" ? "Work Item" : "Task";
     const empty = presentation === "work" ? "No claimable Work Item right now." : "No claimable task right now.";
     const race = presentation === "work" ? "All candidate Work Items were claimed in the race. Check Work again." : "All candidate tasks were claimed in the race. Check the board again.";
@@ -325,11 +363,21 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
     const byId = new Map(tasks.map((task) => [task.id, task]));
     const candidates = id
       ? tasks.filter((task) => task.id === id)
-      : tasks.filter((task) => task.status === "pending" && dependenciesMet(task, byId));
+      : tasks.filter((task) => task.status === "pending" && !task.recoveryRequired && dependenciesMet(task, byId));
     if (candidates.length === 0) {
+      // Say why nothing is claimable: a board whose only pending Work is held for
+      // Leader recovery must not read as an ordinary empty board.
+      const held = loadBoardTasks(binding).filter((task) => task.status === "pending" && task.recoveryRequired);
+      if (!id && held.length > 0) {
+        throw new Error(`No claimable ${label.toLowerCase()} right now. Held for explicit leader recovery: ${held.map((task) => task.id).join(", ")}.`);
+      }
       throw new Error(id ? `${label} "${id}" was not found${presentation === "board" ? " on the board" : ""}.` : empty);
     }
     for (const task of candidates) {
+      if (task.recoveryRequired) {
+        if (id) throw new Error(`Work Item "${task.id}" requires explicit leader Work assignment after failure.`);
+        continue;
+      }
       if (task.status !== "pending" || !dependenciesMet(task, byId)) continue;
       const rejected = claimRejection(binding, task);
       if (rejected) {
@@ -374,7 +422,8 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
       if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
       if (params.action === "list") {
         const tasks = loadBoardTasks(binding);
-        const lines = tasks.map((task) => `- ${task.id} · ${task.status} · ${task.subject}`);
+        const byId = new Map(tasks.map((task) => [task.id, task]));
+        const lines = tasks.map((task) => `- ${task.id} · ${taskStatusLabel(task, byId)} · ${task.subject}`);
         return Promise.resolve({ content: [{ type: "text", text: `WORK · current session\nWORK ITEMS\n${lines.join("\n") || "(none)"}` }], details: { action: "list", outcome: "listed", count: tasks.length } });
       }
       if (params.action === "claim") return queueWorkClaim(params.id, "work");
@@ -390,13 +439,15 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
   async function queueWorkSubmission(input: { taskId: string; status: "completed" | "failed"; result?: string; presentation: "board" | "work" }) {
     const binding = workerBinding();
     if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
-    const assignmentId = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)?.assignment?.id;
+    const authority = reports.authorize(binding, input.status === "failed");
+    if (!authority.assignmentId || authority.taskId !== input.taskId) throw new Error("This turn does not own the submitted Work Item.");
+    const assignmentId = authority.assignmentId;
     const won = createTaskIntent(binding.submissionsDir, input.taskId, {
       taskId: input.taskId, worker: binding.worker, spawnId: binding.spawnId, assignmentId,
       status: input.status, result: input.result, timestamp: Date.now(),
     });
     if (!won) throw new Error(`A submission for "${input.taskId}" is already pending.`);
-    reports.close();
+    reports.close(input.status);
     disclosure.reset();
     const task = loadBoardTasks(binding).find((candidate) => candidate.id === input.taskId);
     const roleVerify = process.env.PI_TEAMMATE_VERIFY_DEFAULT?.trim();
@@ -407,7 +458,7 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
           ? "VERIFY · queued (role gate)"
           : "VERIFY · none configured"
       : "VERIFY · skipped (failed submission)";
-    const next = input.status === "completed" ? "NEXT · wait for the harness result" : input.presentation === "work" ? "NEXT · Work returns to pending" : "NEXT · task returns to pending";
+    const next = "NEXT · End this turn. The harness settles the outcome; do not repeat submission or cancellation acknowledgments.";
     const content = input.presentation === "work"
       ? `WORK · current session\nSUBMISSION INTENT QUEUED · ${input.taskId} · ${input.status === "completed" ? "success" : "failed"}\n${verify}\n${next}`
       : `BOARD · current session\nSUBMITTED · ${input.taskId} · ${input.status}\n${verify}\n${next}`;