@fradser/pi-agent-teams 0.8.3 → 0.9.1

package/src/worker.ts

@@ -1,27 +1,26 @@
 /**
- * Teammate capabilities. A single addressed send_message primitive covers
+ * Teammate 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.
  */
 
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
 import * as path from "node:path";
-import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { detailField, eventToolLifecycle } from "@fradser/pi-kit";
-import { emptyToolCall, renderLifecycleResult } from "./tool-render.ts";
-import { livingTeammates, listTasks } from "./state.ts";
+import { truncateTail, type ExtensionAPI, type MessageEndEvent } from "@earendil-works/pi-coding-agent";
+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 {
+  AgentEventParams,
   LEADER_RECIPIENT,
   messageTitle,
-  SendMessageParams,
-  TaskClaimParams,
-  TaskListParams,
-  TaskSubmitParams,
+  WorkerWorkToolParams,
   type BoardTask,
 } from "./types.ts";
 
-const BOARD_DISCLOSURE_TOOLS = ["task_list", "task_claim", "task_submit"] as const;
+const BOARD_DISCLOSURE_TOOLS = ["work"] as const;
 type BoardDisclosure = "none" | "notice" | "claimed";
 
 export interface WorkerToolDisclosure {
@@ -35,11 +34,7 @@ function createWorkerToolDisclosure(pi: ExtensionAPI): WorkerToolDisclosure {
     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"
-      ? ["task_list", "task_claim"]
-      : state === "claimed"
-        ? ["task_submit"]
-        : [];
+    const revealed = state === "notice" || state === "claimed" ? ["work"] : [];
     pi.setActiveTools([...withoutBoardControls, ...revealed]);
   };
   return {
@@ -49,7 +44,7 @@ function createWorkerToolDisclosure(pi: ExtensionAPI): WorkerToolDisclosure {
         ? readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)
         : undefined;
       const assignment = rosterEntry?.assignment;
-      if (assignment?.kind === "board" && !assignment.closed) state = "claimed";
+      if (assignment && !assignment.closed) state = "claimed";
       else if (!assignment && prompt.includes("=== BOARD NOTICE ===")) state = "notice";
       else state = "none";
       apply();
@@ -90,12 +85,6 @@ export function workerBinding(): WorkerBinding | undefined {
   return { worker, spawnId, outbox, inbox, rosterFile, boardFile, claimsDir, submissionsDir };
 }
 
-function livingRecipients(binding: WorkerBinding): Set<string> {
-  return new Set(readRoster(binding.rosterFile)
-    .filter((entry) => entry.status !== "stopped")
-    .map((entry) => entry.name));
-}
-
 function loadBoardTasks(binding: WorkerBinding): BoardTask[] {
   const board = readBoardFile(binding.boardFile);
   return Object.values(board?.tasks ?? {}).sort((a, b) => a.id.localeCompare(b.id));
@@ -151,212 +140,290 @@ export function renderTaskBoard(tasks: BoardTask[]): string {
   return lines.join("\n");
 }
 
-function renderRoster(roster: string): string {
-  return `ROSTER\n${roster || "(none)"}`;
+type AssistantResponse = Extract<MessageEndEvent["message"], { role: "assistant" }>;
+type AutomaticResult = { status: "completed" | "failed"; body: string };
+
+function executionResult(message?: AssistantResponse): AutomaticResult {
+  if (message?.stopReason === "error" || message?.stopReason === "aborted") {
+    return { status: "failed", body: message.errorMessage?.trim() || `Execution ${message.stopReason} without a final answer.` };
+  }
+  if (message?.stopReason === "length") return { status: "failed", body: "Execution reached the response length limit without a complete final answer." };
+  if (message && message.stopReason !== "stop" && message.stopReason !== "toolUse") {
+    return { status: "failed", body: `Execution settled with an incomplete response (${message.stopReason}) and no final answer.` };
+  }
+  const body = message?.content.filter((part) => part.type === "text").map((part) => part.text).join("\n") ?? "";
+  if (message?.stopReason === "stop" && !message.content.some((part) => part.type === "toolCall") && body.trim()) {
+    return { status: "completed", body };
+  }
+  return { status: "failed", body: "Execution settled without a final answer." };
 }
 
-/** One registration shared by leader and worker; binding chooses the data source. */
-export function registerTaskListTool(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "task_list",
-    promptSnippet: "Read the shared task board",
-    label: "Task Board",
-    description: "Read the current session board as grouped task state plus a compact roster. Pending tasks with met dependencies are claimable.",
-    parameters: TaskListParams,
-    renderShell: "self",
-    renderCall: emptyToolCall,
-    renderResult(result, options, theme, context) {
-      const count = detailField<number>(result.details, "count") ?? 0;
-      return renderLifecycleResult(result, options, theme, context, eventToolLifecycle(
-        "board",
-        `${count} task${count === 1 ? "" : "s"}`,
-        { label: "listed" },
-      ));
-    },
-    async execute() {
-      const binding = workerBinding();
-      const tasks = binding ? loadBoardTasks(binding) : listTasks();
-      // Both sides get a roster tail: peer discovery is zero-cost for workers.
-      const roster = binding
-        ? readRoster(binding.rosterFile)
-            .filter((entry) => entry.status !== "stopped")
-            .map((entry) => `@${entry.name} (${entry.agent}, ${entry.status}${entry.assignment ? `, ${entry.assignment.kind} ${entry.assignment.id}` : ""})`)
-            .join("\n")
-        : livingTeammates().map((t) => `@${t.name} (${t.agent}, ${t.status}${t.currentTaskId ? `, task ${t.currentTaskId}` : ""})`).join("\n");
-      const leaderHint = !binding && !roster && tasks.some((task) => task.status === "pending")
-        ? "NEXT · leader: teammate_spawn; workers then use task_claim"
-        : tasks.some((task) => task.status === "pending")
-          ? "NEXT · workers use task_claim for pending/claimable tasks"
-          : "NEXT · no claimable work";
-      return {
-        content: [{ type: "text", text: `${renderTaskBoard(tasks)}\n${leaderHint}\n\n${renderRoster(roster)}` }],
-        details: { count: tasks.length },
-      };
-    },
+function automaticResultBody(binding: WorkerBinding, assignmentId: string, body: string): string {
+  if (Buffer.byteLength(JSON.stringify(body), "utf-8") <= 48 * 1024) return body;
+  const key = createHash("sha256").update(binding.spawnId).update("\0").update(assignmentId).digest("hex");
+  const file = path.join(path.dirname(binding.outbox), `${key}.result.txt`);
+  const temporary = `${file}.${process.pid}.tmp`;
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  try {
+    fs.writeFileSync(temporary, body, { encoding: "utf-8", mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+  const preview = truncateTail(body, { maxBytes: 8 * 1024, maxLines: 200 });
+  return `${preview.content}\n\n[Result truncated; ${preview.totalBytes} bytes total]\nFull result: ${file}`;
+}
+
+function createWorkerReports(pi: ExtensionAPI) {
+  const initial = workerBinding();
+  const initialAssignment = initial ? readRoster(initial.rosterFile).find((entry) => entry.name === initial.worker)?.assignment : undefined;
+  let assignmentId = initialAssignment?.id;
+  let reportClosed = initialAssignment?.closed === true;
+  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 assignment = self?.assignment;
+    return !reportClosed && self?.spawnId === binding.spawnId && self.status !== "stopped"
+      && assignment && assignment.id === assignmentId && !assignment.closed ? assignment : undefined;
+  };
+  const close = () => {
+    reportClosed = true;
+    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;
+    }
+    if (reportClosed) throw new Error("Leader report rejected: this assignment already has a terminal report. Wait for an explicit leader assignment.");
+    return assignmentId;
+  };
+  pi.on("message_start", ({ message }) => {
+    const binding = workerBinding();
+    if (!binding) return;
+    if (message.role === "user") {
+      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;
+      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;
+        assignmentId = id;
+        pending = undefined;
+      }
+      const assignment = currentAssignment(binding);
+      if (assignment) pending = { binding, assignmentId: assignment.id, timestamp: message.timestamp };
+    } else if (message.role === "assistant" && pending && message.timestamp >= pending.timestamp) {
+      pending.timestamp = message.timestamp;
+      pending.awaitingFinal = true;
+      pending.outcome = undefined;
+    }
+  });
+  pi.on("agent_start", () => {
+    if (pending) {
+      pending.outcome = undefined;
+      pending.awaitingFinal = false;
+    }
+  });
+  pi.on("message_end", ({ message }) => {
+    if (message.role !== "assistant" || !pending?.awaitingFinal || message.timestamp < pending.timestamp
+      || finalizedMessages.has(message) || !currentAssignment(pending.binding)) return;
+    finalizedMessages.add(message);
+    pending.timestamp = message.timestamp;
+    pending.awaitingFinal = false;
+    pending.outcome = executionResult(message);
+  });
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!pending || !ctx.isIdle()) return;
+    const binding = workerBinding();
+    if (!binding || binding.worker !== pending.binding.worker || binding.spawnId !== pending.binding.spawnId
+      || binding.outbox !== pending.binding.outbox || pending.assignmentId !== assignmentId || !currentAssignment(binding)) return;
+    const result = pending.outcome ?? executionResult();
+    appendWorkerEvent(binding.outbox, {
+      id: randomUUID(), type: "message", worker: binding.worker, spawnId: binding.spawnId,
+      assignmentId: pending.assignmentId, timestamp: Date.now(), status: result.status,
+      body: automaticResultBody(binding, pending.assignmentId, result.body),
+    });
+    close();
   });
+  return {
+    close,
+    send(binding: WorkerBinding, body: string, status: import("./types.ts").WorkerReportEvent["status"]) {
+      appendWorkerEvent(binding.outbox, {
+        assignmentId: reportAssignment(binding), id: randomUUID(), type: "message",
+        worker: binding.worker, spawnId: binding.spawnId, body, status, timestamp: Date.now(),
+      });
+      const isTerminal = status === "completed" || status === "failed";
+      if (isTerminal) close();
+      return isTerminal;
+    },
+    reset() { pending = undefined; },
+  };
 }
 
 export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosure {
   const disclosure = createWorkerToolDisclosure(pi);
+  const reports = createWorkerReports(pi);
   pi.registerTool({
-    name: "send_message",
-    promptSnippet: "Send a message to the leader or a teammate",
-    label: "Send Message",
-    description: "The only messaging primitive. Use to=\"leader\" for reports; use a teammate name for direct peer mail. status is valid only for leader reports.",
-    parameters: SendMessageParams,
+    name: "agent_event",
+    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.",
+    parameters: AgentEventParams,
     renderShell: "self",
     renderCall: emptyToolCall,
     renderResult(result, options, theme, context) {
-      const to = String((context.args as { to?: string }).to ?? "");
-
-      return renderLifecycleResult(result, options, theme, context, eventToolLifecycle(
+      return renderCoordinationRow(
+        result, options, theme, context,
         "message",
-        detailField<"steered" | "queued">(result.details, "outcome") ?? "queued",
-        { label: `to @${to}` },
-      ));
+        messageRow(context.args as { to?: string; message?: string }, result.details, { isError: context.isError }),
+      );
     },
     async execute(_toolCallId, params) {
       const binding = workerBinding();
       if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
-      if (params.to === LEADER_RECIPIENT) {
+      if (!params.to || params.to === LEADER_RECIPIENT) {
         appendWorkerEvent(binding.outbox, {
-          id: randomUUID(),
-          type: "message",
-          worker: binding.worker,
-          spawnId: binding.spawnId,
-          body: params.message,
-          status: params.status,
-          timestamp: Date.now(),
+          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(),
         });
         return {
-          content: [{ type: "text", text: params.status
-            ? `MESSAGING\nREPORT · to=leader · status=${params.status}\nNEXT · harness will deliver this report`
-            : 'MESSAGING\nREPORT · to=leader · status=in_progress\nNEXT · send status="completed" or status="failed" to end the assignment' }],
-          details: { to: LEADER_RECIPIENT, status: params.status ?? "in_progress", outcome: "queued" },
-          terminate: params.status === "completed" || params.status === "failed",
+          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" },
         };
       }
-      if (params.status) throw new Error('status is valid only when to="leader".');
-      if (params.to === binding.worker) throw new Error("You are already the recipient — no need to message yourself.");
-      if (!livingRecipients(binding).has(params.to)) {
-        throw new Error(`No living teammate named "${params.to}". Check the roster or ask the leader.`);
-      }
-      const recipientInbox = path.join(path.dirname(binding.inbox), `inbox-${encodeURIComponent(params.to)}.jsonl`);
+      const recipient = resolveRecipient(params.to, readRoster(binding.rosterFile));
+      const to = recipient.name;
+      if (to === binding.worker) throw new Error("You are already the recipient — no need to message yourself.");
+      const recipientInbox = path.join(path.dirname(binding.inbox), `inbox-${encodeURIComponent(to)}.jsonl`);
       appendInboxMessage(recipientInbox, {
         id: randomUUID(),
         from: binding.worker,
         subject: messageTitle(params.message),
         body: params.message,
+        ...(recipient.spawnId ? { toSpawnId: recipient.spawnId } : {}),
       });
       return {
-        content: [{ type: "text", text: `MESSAGING\nQUEUED · to=@${params.to}\nNEXT · harness will route the inbox message into a recipient turn` }],
-        details: { to: params.to, outcome: "queued" },
+        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" },
       };
     },
   });
 
-  registerTaskListTool(pi);
+  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.");
+    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 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));
+    if (candidates.length === 0) {
+      throw new Error(id ? `${label} "${id}" was not found${presentation === "board" ? " on the board" : ""}.` : empty);
+    }
+    for (const task of candidates) {
+      if (task.status !== "pending" || !dependenciesMet(task, byId)) continue;
+      const rejected = claimRejection(binding, task);
+      if (rejected) {
+        if (id) throw new Error(rejected);
+        continue;
+      }
+      const won = createTaskIntent(binding.claimsDir, task.id, {
+        taskId: task.id, worker: 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`;
+        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 };
+        return { content: [{ type: "text" as const, text: content }], details };
+      }
+      if (id) throw new Error(`${label} "${task.id}" was claimed by someone else first.`);
+    }
+    throw new Error(race);
+  }
 
   pi.registerTool({
-    name: "task_claim",
+    name: "work",
     renderShell: "self",
     renderCall: emptyToolCall,
     renderResult(result, options, theme, context) {
-      const taskId = String((context.args as { taskId?: string }).taskId ?? "first claimable");
-      return renderLifecycleResult(result, options, theme, context, eventToolLifecycle(
-        "board",
-        taskId,
-        { label: "claim queued" },
-      ));
+      const params = context.args as { action?: string; id?: string };
+      return renderCoordinationRow(
+        result, options, theme, context,
+        "work",
+        workerWorkRow(params, result.details, textOf(result), { isError: context.isError }),
+      );
     },
-    promptSnippet: "Self-claim a pending board task",
-    label: "Claim Task",
-    description: "Atomically claim a pending task whose dependencies are met. Omit taskId to claim the first claimable task.",
-    parameters: TaskClaimParams,
-    async execute(_toolCallId, params) {
+    promptSnippet: "Claim pending Work or submit owned Work",
+    label: "Work",
+    description: "Queue a claim for pending Work or submit the current owned Work Item. The harness remains the authority for claim acceptance and completion.",
+    parameters: WorkerWorkToolParams,
+    execute(_toolCallId, params) {
       const binding = workerBinding();
       if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
-      const tasks = loadBoardTasks(binding);
-      const byId = new Map(tasks.map((task) => [task.id, task]));
-      const candidates = params.taskId
-        ? tasks.filter((task) => task.id === params.taskId)
-        : tasks.filter((task) => task.status === "pending" && dependenciesMet(task, byId));
-      if (candidates.length === 0) {
-        throw new Error(params.taskId ? `Task "${params.taskId}" was not found on the board.` : "No claimable task right now.");
+      if (params.action === "list") {
+        const tasks = loadBoardTasks(binding);
+        const lines = tasks.map((task) => `- ${task.id} · ${task.status} · ${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 } });
       }
-      for (const task of candidates) {
-        if (task.status !== "pending" || !dependenciesMet(task, byId)) continue;
-        const rejected = claimRejection(binding, task);
-        if (rejected) {
-          if (params.taskId) throw new Error(rejected);
-          continue;
-        }
-        const won = createTaskIntent(binding.claimsDir, task.id, {
-          taskId: task.id,
-          worker: binding.worker,
-          spawnId: binding.spawnId,
-          timestamp: Date.now(),
-        });
-        if (won) {
-          return {
-            content: [{ type: "text", text: `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` }],
-            details: { taskId: task.id, subject: task.subject, worker: binding.worker },
-          };
-        }
-        if (params.taskId) throw new Error(`Task "${task.id}" was claimed by someone else first.`);
+      if (params.action === "claim") return queueWorkClaim(params.id, "work");
+      const self = readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker);
+      if (!self?.assignment || !self.currentTaskId) throw new Error("You do not own a claimed Work Item.");
+      if (params.action === "release") {
+        return queueWorkSubmission({ taskId: self.currentTaskId, status: "failed", result: params.result, presentation: "work" });
       }
-      throw new Error("All candidate tasks were claimed in the race. Check the board again.");
+      return queueWorkSubmission({ taskId: self.currentTaskId, status: params.outcome === "success" ? "completed" : "failed", result: params.result, presentation: "work" });
     },
   });
 
-  pi.registerTool({
-    name: "task_submit",
-    renderShell: "self",
-    renderCall: emptyToolCall,
-    renderResult(result, options, theme, context) {
-      const taskId = String((context.args as { taskId?: string }).taskId ?? "task");
-      const status = String((context.args as { status?: string }).status ?? "submitted");
-      return renderLifecycleResult(result, options, theme, context, eventToolLifecycle(
-        "board",
-        taskId,
-        { label: status },
-      ));
-    },
-    promptSnippet: "Submit a claimed task outcome",
-    label: "Submit Task",
-    description: "Submit a task you claimed. completed runs its verify gate; failed releases the task back to the board.",
-    parameters: TaskSubmitParams,
-    async execute(_toolCallId, params) {
-      const binding = workerBinding();
-      if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
-      const won = createTaskIntent(binding.submissionsDir, params.taskId, {
-        taskId: params.taskId,
-        worker: binding.worker,
-        spawnId: binding.spawnId,
-        status: params.status,
-        result: params.result,
-        timestamp: Date.now(),
-      });
-      if (!won) throw new Error(`A submission for "${params.taskId}" is already pending.`);
+  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 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();
+    disclosure.reset();
+    const task = loadBoardTasks(binding).find((candidate) => candidate.id === input.taskId);
+    const roleVerify = process.env.PI_TEAMMATE_VERIFY_DEFAULT?.trim();
+    const verify = input.status === "completed"
+      ? task?.verify
+        ? "VERIFY · queued (task gate)"
+        : roleVerify
+          ? "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 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}`;
+    // 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.
+    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) };
+    return { content: [{ type: "text" as const, text: content }], details, terminate: true };
+  }
+
+  return {
+    update: disclosure.update,
+    reset() {
       disclosure.reset();
-      const task = loadBoardTasks(binding).find((candidate) => candidate.id === params.taskId);
-      const roleVerify = process.env.PI_TEAMMATE_VERIFY_DEFAULT?.trim();
-      const verify = params.status === "completed"
-        ? task?.verify
-          ? "VERIFY · queued (task gate)"
-          : roleVerify
-            ? "VERIFY · queued (role gate)"
-            : "VERIFY · none configured"
-        : "VERIFY · skipped (failed submission)";
-      const next = params.status === "completed"
-        ? "NEXT · wait for the harness result"
-        : "NEXT · task returns to pending";
-      return {
-        content: [{ type: "text", text: `BOARD · current session\nSUBMITTED · ${params.taskId} · ${params.status}\n${verify}\n${next}` }],
-        details: { taskId: params.taskId, status: params.status, verify: Boolean(task?.verify || roleVerify) },
-      };
+      reports.reset();
     },
-  });
-
-  return disclosure;
+  };
 }