@fradser/pi-agent-teams 0.9.2 → 1.0.0

package/src/worker.ts

@@ -1,5 +1,6 @@
+import { isTaskReplaced } from "@fradser/pi-tasks";
 /**
- * Teammate capabilities. A single addressed agent_event primitive covers
+ * Agent capabilities. A single addressed agent_event primitive covers
  * leader reports and peer mail. Task-list registration is shared by leader
  * and worker processes; claiming and submitting remain worker-only.
  */
@@ -8,34 +9,41 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { truncateTail, type ExtensionAPI, type MessageEndEvent } from "@earendil-works/pi-coding-agent";
+import { setOwnedTools } from "@fradser/pi-kit";
+import { isTaskStatus, resourcesConflict, type TaskStatus } from "@fradser/pi-tasks";
 import { messageRow, workerWorkRow } from "./tool-copy.ts";
 import { emptyToolCall, renderCoordinationRow, textOf } from "./tool-render.ts";
 import { resolveRecipient } from "./recipient.ts";
-import { appendInboxMessage, appendWorkerEvent, createTaskIntent, readBoardFile, readRoster } from "./statefile.ts";
+import { appendInboxMessage, appendWorkerEvent, readRoster } from "./statefile.ts";
+import { createTaskIntent, readTasksFile } from "@fradser/pi-tasks";
 import {
   AgentEventParams,
   LEADER_RECIPIENT,
   messageTitle,
   WorkerWorkToolParams,
-  type BoardTask,
+  type Task,
 } from "./types.ts";
 
-const BOARD_DISCLOSURE_TOOLS = ["work"] as const;
-type BoardDisclosure = "none" | "notice" | "claimed";
+const TASK_DISCLOSURE_TOOLS = ["task"] as const;
+/** Why the tasks tool is shown to this worker. `held` means it already
+ *  owns an assignment, which is a fact about this worker rather than a task
+ *  status — the two were never the same state and must not share a word. */
+type TaskDisclosure = "none" | "notice" | "held";
 
 export interface WorkerToolDisclosure {
-  update(prompt: string): void;
+  update(prompt?: string): void;
   reset(): void;
 }
 
 function createWorkerToolDisclosure(pi: ExtensionAPI): WorkerToolDisclosure {
-  let state: BoardDisclosure = "none";
+  let state: TaskDisclosure = "none";
   const apply = () => {
     if (typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return;
-    const active = pi.getActiveTools();
-    const withoutBoardControls = active.filter((tool) => !BOARD_DISCLOSURE_TOOLS.includes(tool as typeof BOARD_DISCLOSURE_TOOLS[number]));
-    const revealed = state === "notice" || state === "claimed" ? ["work"] : [];
-    pi.setActiveTools([...withoutBoardControls, ...revealed]);
+    const revealed = state === "notice" || state === "held" ? ["task"] : [];
+    // `work` is re-asserted from the owned set rather than the snapshot, so this
+    // disclosure write cannot deactivate a tool the harness has not published
+    // yet. See setOwnedTools.
+    setOwnedTools(pi, { owned: TASK_DISCLOSURE_TOOLS, toggled: revealed, enabled: revealed.length > 0 });
   };
   return {
     update(prompt) {
@@ -44,8 +52,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 = "held";
+      } else if (!assignment && prompt?.includes("=== TASK NOTICE ===")) state = "notice";
       else state = "none";
       apply();
     },
@@ -62,7 +74,7 @@ export interface WorkerBinding {
   outbox: string;
   inbox: string;
   rosterFile: string;
-  boardFile: string;
+  tasksFile: string;
   claimsDir: string;
   submissionsDir: string;
 }
@@ -73,7 +85,7 @@ const REQUIRED_ENV = [
   "PI_TEAMMATE_OUTBOX_FILE",
   "PI_TEAMMATE_INBOX_FILE",
   "PI_TEAMMATE_ROSTER_FILE",
-  "PI_TEAMMATE_BOARD_FILE",
+  "PI_TEAMMATE_TASKS_FILE",
   "PI_TEAMMATE_CLAIMS_DIR",
   "PI_TEAMMATE_SUBMISSIONS_DIR",
 ] as const;
@@ -81,35 +93,40 @@ const REQUIRED_ENV = [
 export function workerBinding(): WorkerBinding | undefined {
   const values = REQUIRED_ENV.map((name) => process.env[name]);
   if (values.some((value) => !value)) return undefined;
-  const [worker, spawnId, outbox, inbox, rosterFile, boardFile, claimsDir, submissionsDir] = values as string[];
-  return { worker, spawnId, outbox, inbox, rosterFile, boardFile, claimsDir, submissionsDir };
+  const [worker, spawnId, outbox, inbox, rosterFile, tasksFile, claimsDir, submissionsDir] = values as string[];
+  return { worker, spawnId, outbox, inbox, rosterFile, tasksFile, claimsDir, submissionsDir };
 }
 
-function loadBoardTasks(binding: WorkerBinding): BoardTask[] {
-  const board = readBoardFile(binding.boardFile);
-  return Object.values(board?.tasks ?? {}).sort((a, b) => a.id.localeCompare(b.id));
+function loadWorkerTasks(binding: WorkerBinding): Task[] {
+  const tasks = readTasksFile(binding.tasksFile);
+  return Object.values(tasks?.tasks ?? {}).map(task => {
+    // Workers read the leader's file without restoring the shared store. Legacy
+    // files can still be present until its next mutation, so normalize status
+    // here without resetting an active participant's holding.
+    const raw: unknown = task.status;
+    const status = raw === "recovery_hold" ? "blocked"
+      : raw === "superseded" ? (task.supersededBy ? "pending" : "blocked")
+      : isTaskStatus(raw) ? raw : "blocked";
+    return { ...task, status, ...(raw === "superseded" && !task.supersededBy ? { replacementUnresolved: true } : {}) };
+  }).sort((a, b) => a.id.localeCompare(b.id));
 }
 
-function dependenciesMet(task: BoardTask, tasks: Map<string, BoardTask>): boolean {
+function dependenciesMet(task: Task, tasks: Map<string, Task>): boolean {
   return task.dependsOn.every((dep) => tasks.get(dep)?.status === "completed");
 }
 
-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;
-  return `tasks=${tasks.length} · pending=${counts.pending} (${claimable} claimable) · claimed=${counts.claimed} · completed=${counts.completed} · superseded=${counts.superseded}`;
+function taskCounts(tasks: Task[], byId: Map<string, Task>): string {
+  const counts: Record<TaskStatus, number> = { pending: 0, in_progress: 0, blocked: 0, completed: 0, cancelled: 0 };
+  for (const task of tasks) if (!isTaskReplaced(task)) counts[task.status] += 1;
+  const claimable = tasks.filter((task) => !isTaskReplaced(task) && task.status === "pending" && dependenciesMet(task, byId)).length;
+  return `tasks=${tasks.length} · pending=${counts.pending} (${claimable} claimable) · in_progress=${counts.in_progress} · blocked=${counts.blocked} · completed=${counts.completed} · cancelled=${counts.cancelled} · superseded=${tasks.filter(isTaskReplaced).length}`;
 }
 
-function resourcesConflict(left: readonly string[] | undefined, right: readonly string[] | undefined): boolean {
-  return (left ?? []).some((a) => (right ?? []).some((b) => a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`)));
-}
-
-function claimRejection(binding: WorkerBinding, task: BoardTask): string | undefined {
+function claimRejection(binding: WorkerBinding, task: Task): string | undefined {
   const self = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker);
   if (self?.assignment) {
     const state = self.assignment.closed ? "closed pending leader reopen" : "active";
-    return `You already own ${state} ${self.assignment.kind} assignment "${self.assignment.id}". Finish it through its matching protocol before claiming board work.`;
+    return `You already own ${state} ${self.assignment.kind} assignment "${self.assignment.id}". Finish it through its matching protocol before claiming task work.`;
   }
   const conflict = readRoster(binding.rosterFile).find((entry) => entry.name !== binding.worker
     && entry.assignment && !entry.assignment.closed
@@ -120,14 +137,19 @@ function claimRejection(binding: WorkerBinding, task: BoardTask): string | undef
   return undefined;
 }
 
-function taskStatusLabel(task: BoardTask, tasks: Map<string, BoardTask>): string {
+function taskStatusLabel(task: Task, tasks: Map<string, Task>): string {
+  // `blocked` is a state of its own, so it is named as one. A task in it
+  // was attempted and the attempt did not stand: it is not claimable work, and
+  // calling it "pending" hid that from the participant reading this list.
+  if (isTaskReplaced(task)) return task.supersededBy ? `replaced-by=${task.supersededBy}` : "replacement-unresolved";
+  if (task.status === "blocked") return "blocked";
   if (task.status === "pending") return dependenciesMet(task, tasks) ? "pending/claimable" : "pending/blocked";
   return task.status;
 }
 
-export function renderTaskBoard(tasks: BoardTask[]): string {
+export function renderTaskList(tasks: Task[]): string {
   const byId = new Map(tasks.map((task) => [task.id, task]));
-  const lines = [`BOARD · current session`, `SUMMARY · ${taskCounts(tasks, byId)}`];
+  const lines = [`TASKS · current session`, `SUMMARY · ${taskCounts(tasks, byId)}`];
   if (tasks.length === 0) return `${lines.join("\n")}\nTASKS\n(no tasks)`;
   lines.push("TASKS");
   for (const task of tasks) {
@@ -176,30 +198,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 (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.");
     }
-    if (reportClosed) throw new Error("Leader report rejected: this assignment already has a terminal report. Wait for an explicit leader assignment.");
-    return assignmentId;
+    const cancelled = cancellation && assignmentId && self.currentTaskId
+      && (self.assignment?.closed || loadWorkerTasks(binding).some((task) => task.id === self.currentTaskId && isTaskReplaced(task)));
+    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 +243,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, tasks 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,31 +299,33 @@ 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; },
   };
 }
 
-export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosure {
+export function registerChildCapabilities(pi: ExtensionAPI): WorkerToolDisclosure {
   const disclosure = createWorkerToolDisclosure(pi);
   const reports = createWorkerReports(pi);
   pi.registerTool({
-    name: "agent_event",
+    name: "message",
     promptSnippet: "Send an event or message to a participant",
     label: "Agent Event",
-    description: "Communication-only interface across Leader, Worker, and Peers. Work completion is reported automatically after settlement or uses work action=submit.",
+    description: "Communication-only interface across Leader, Worker, and Peers. Task completion is reported automatically after settlement or delivered with task action=complete.",
     parameters: AgentEventParams,
     renderShell: "self",
     renderCall: emptyToolCall,
@@ -287,14 +339,15 @@ 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,
-          body: params.message, status: params.intent ?? "inform", timestamp: Date.now(),
+          assignmentId: authority.assignmentId, id: randomUUID(), type: "message", worker: binding.worker, spawnId: binding.spawnId,
+          body: params.body, status: params.kind ?? "inform", timestamp: Date.now(),
         });
         return {
-          content: [{ type: "text", text: `MESSAGING\nREPORT · to=leader · intent=${params.intent ?? "inform"}\nNEXT · harness will deliver this message; Work completion is automatic or uses work submit` }],
-          details: { to: LEADER_RECIPIENT, intent: params.intent ?? "inform", outcome: "queued" },
+          content: [{ type: "text", text: `MESSAGING\nREPORT · to=leader · kind=${params.kind ?? "inform"}\nNEXT · harness will deliver this message; Task completion is automatic or uses task complete` }],
+          details: { to: LEADER_RECIPIENT, kind: params.kind ?? "inform", outcome: "queued" },
         };
       }
       const recipient = resolveRecipient(params.to, readRoster(binding.rosterFile));
@@ -304,32 +357,49 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
       appendInboxMessage(recipientInbox, {
         id: randomUUID(),
         from: binding.worker,
-        subject: messageTitle(params.message),
-        body: params.message,
+        subject: messageTitle(params.body),
+        body: params.body,
         ...(recipient.spawnId ? { toSpawnId: recipient.spawnId } : {}),
       });
       return {
         content: [{ type: "text", text: `MESSAGING\nQUEUED · to=@${to}\nNEXT · harness will route the inbox message into a recipient turn` }],
-        details: { to, outcome: "queued", intent: params.intent ?? "inform" },
+        details: { to, outcome: "queued", kind: params.kind ?? "inform" },
       };
     },
   });
 
-  async function queueWorkClaim(id: string | undefined, presentation: "board" | "work") {
+  async function queueWorkClaim(id: string | undefined, presentation: "task" | "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 task 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.";
-    const tasks = loadBoardTasks(binding);
+    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 tasks again.";
+    const tasks = loadWorkerTasks(binding);
     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) => !isTaskReplaced(task) && task.status === "pending" && dependenciesMet(task, byId));
     if (candidates.length === 0) {
-      throw new Error(id ? `${label} "${id}" was not found${presentation === "board" ? " on the board" : ""}.` : empty);
+      // Say why nothing is claimable: a task set whose only pending Work is held for
+      // Leader recovery must not read as an ordinary empty tasks.
+      const held = loadWorkerTasks(binding).filter((task) => task.status === "blocked");
+      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 === "task" ? " in the task list" : ""}.` : empty);
     }
     for (const task of candidates) {
+      if (task.status === "blocked") {
+        if (id) throw new Error(`Work Item "${task.id}" requires explicit leader Work assignment after failure.`);
+        continue;
+      }
+      if (isTaskReplaced(task)) {
+        if (id) throw new Error(task.supersededBy ? `Work Item "${task.id}" was replaced by "${task.supersededBy}".` : `Work Item "${task.id}" has an unresolved replacement target.`);
+        continue;
+      }
       if (task.status !== "pending" || !dependenciesMet(task, byId)) continue;
       const rejected = claimRejection(binding, task);
       if (rejected) {
@@ -337,12 +407,12 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
         continue;
       }
       const won = createTaskIntent(binding.claimsDir, task.id, {
-        taskId: task.id, worker: binding.worker, spawnId: binding.spawnId, timestamp: Date.now(),
+        taskId: task.id, participant: binding.worker, spawnId: binding.spawnId, timestamp: Date.now(),
       });
       if (won) {
         const content = presentation === "work"
           ? `WORK · current session\nCLAIM INTENT QUEUED · ${task.id} · ${task.subject}\nREQUESTER · @${binding.worker}\nNEXT · wait for harness claim acceptance before starting Work`
-          : `BOARD · current session\nCLAIM INTENT QUEUED · ${task.id} · ${task.subject}\nREQUESTER · @${binding.worker}\nNEXT · wait for harness Claim accepted feedback; do not start work until it arrives`;
+          : `TASKS · current session\nCLAIM INTENT QUEUED · ${task.id} · ${task.subject}\nREQUESTER · @${binding.worker}\nNEXT · wait for harness Claim accepted feedback; do not start work until it arrives`;
         const details = presentation === "work"
           ? { action: "claim", outcome: "queued", id: task.id, subject: task.subject, worker: binding.worker }
           : { taskId: task.id, subject: task.subject, worker: binding.worker };
@@ -354,7 +424,7 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
   }
 
   pi.registerTool({
-    name: "work",
+    name: "task",
     renderShell: "self",
     renderCall: emptyToolCall,
     renderResult(result, options, theme, context) {
@@ -373,8 +443,9 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
       const binding = workerBinding();
       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 tasks = loadWorkerTasks(binding);
+        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");
@@ -387,18 +458,20 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosu
     },
   });
 
-  async function queueWorkSubmission(input: { taskId: string; status: "completed" | "failed"; result?: string; presentation: "board" | "work" }) {
+  async function queueWorkSubmission(input: { taskId: string; status: "completed" | "failed"; result?: string; presentation: "task" | "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,
+      taskId: input.taskId, participant: 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 task = loadWorkerTasks(binding).find((candidate) => candidate.id === input.taskId);
     const roleVerify = process.env.PI_TEAMMATE_VERIFY_DEFAULT?.trim();
     const verify = input.status === "completed"
       ? task?.verify
@@ -407,12 +480,12 @@ 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}`;
+      : `TASKS · current session\nSUBMITTED · ${input.taskId} · ${input.status}\n${verify}\n${next}`;
     // The subject rides along in details: a worker process never hydrates the
-    // leader's in-memory board, so its row cannot look the task up by itself.
+    // leader's in-memory tasks, so its row cannot look the task up by itself.
     const details = input.presentation === "work"
       ? { action: "submit", outcome: "queued", id: input.taskId, subject: task?.subject, status: input.status === "completed" ? "success" : "failed", verify: Boolean(task?.verify || roleVerify) }
       : { taskId: input.taskId, subject: task?.subject, status: input.status, verify: Boolean(task?.verify || roleVerify) };