@fradser/pi-agent-teams 0.8.0 → 0.8.2

package/src/ui.ts

@@ -9,6 +9,9 @@ import {
   modelSearchText,
   PI_SPINNER_FRAMES,
   PI_SPINNER_INTERVAL_MS,
+  notifyPi,
+  renderPiPanel,
+  renderPiWidgetRow,
   sortModels,
   type SearchPicker,
 } from "@fradser/pi-kit";
@@ -18,7 +21,7 @@ import {
 } from "./console-viewport.ts";
 import { fitTeammateRow, formatTeammateLabel, runningTeammateActivity } from "./activity.ts";
 import { MODEL_INHERIT_ALIAS, discoverAgents, resolveAgent, type AgentDefinition } from "./agents.ts";
-import { getState, getTeammate, getTeamDefaultModel, listTasks, listTeammates, livingTeammates, setTeamDefaultModel } from "./state.ts";
+import { getPeerDeliveryState, getState, getTeammate, getTeamDefaultModel, listTasks, listTeammates, livingTeammates, setTeamDefaultModel } from "./state.ts";
 import {
   currentLeaderModelRef,
   ensureLivePoll,
@@ -26,8 +29,8 @@ import {
   resolveSpawnModel,
   runtimeDirPath,
   shutdownTeammate,
-  STALL_NOTICE_MS,
   stallSilenceMs,
+  stallThresholdMs,
 } from "./team-machine.ts";
 import type { Teammate } from "./types.ts";
 import { mapPickerKey } from "./picker-keys.ts";
@@ -91,13 +94,13 @@ export function ensureTeamWidget(ctx?: { ui?: ExtensionUIContext; mode?: string
         if (working.length === 0) return [];
         const lines: string[] = [];
         for (const teammate of working) {
-          lines.push(fitTeammateRow(
+          lines.push(renderPiWidgetRow(fitTeammateRow(
             PI_SPINNER_FRAMES[spinnerFrame],
             style.fg(colorFor(teammate.name), teammate.name),
             runningTeammateActivity(teammate) + stallSuffix(teammate),
-            width,
+            Math.max(1, width - 1),
             (activity) => theme.bold(style.fg("accent", activity)),
-          ));
+          ), width, truncateToWidth));
         }
         return lines;
       },
@@ -111,11 +114,12 @@ function isWorking(teammate: { status: string }): boolean {
   return teammate.status === "working" || teammate.status === "starting";
 }
 
-/** Silence marker appended once a working teammate passes the stall notice threshold. */
+/** Silence marker appended once a working teammate passes its stall threshold. */
 function stallSuffix(teammate: Teammate): string {
   if (!isWorking(teammate)) return "";
   const silence = stallSilenceMs(teammate);
-  return silence !== undefined && STALL_NOTICE_MS > 0 && silence >= STALL_NOTICE_MS
+  const threshold = stallThresholdMs(teammate);
+  return silence !== undefined && threshold > 0 && silence >= threshold
     ? ` · stalled for ${formatSilenceDuration(silence)}`
     : "";
 }
@@ -134,6 +138,7 @@ function cap(text: string | undefined, maxBytes = 2000): string {
 // ── Detail builders ───────────────────────────────────────────────
 
 interface PeerMailLine {
+  id: string;
   direction: "sent" | "received";
   counterpart: string;
   subject: string;
@@ -167,6 +172,7 @@ function readPeerMail(teammateName: string): PeerMailLine[] {
         if (!message.id || !message.from || !message.subject) continue;
         if (message.from !== teammateName && recipient !== teammateName) continue;
         lines.push({
+          id: message.id,
           direction: message.from === teammateName ? "sent" : "received",
           counterpart: message.from === teammateName ? recipient : message.from,
           subject: message.subject,
@@ -202,6 +208,7 @@ function buildTeammateDetail(name: string): string[] {
     `  Status: ${teammate.status}${teammate.currentTaskId ? ` | Task: ${teammate.currentTaskId}` : ""}`,
     `  Spawn: ${teammate.pid > 0 ? `pid ${teammate.pid}` : "pid unknown"} | Isolation: ${teammate.isolation}`,
     ...(teammate.model ? [`  Launch model: ${teammate.model}`] : []),
+    ...(teammate.tools?.length ? [`  Tools: ${teammate.tools.join(", ")}`] : []),
     `  Created: ${new Date(teammate.createdAt).toLocaleString()}`,
   ];
   if (teammate.stoppedAt) lines.push(`  Stopped: ${new Date(teammate.stoppedAt).toLocaleString()}`);
@@ -217,7 +224,8 @@ function buildTeammateDetail(name: string): string[] {
   lines.push("", `== reports to leader (${reports.length}) ==`);
   if (reports.length === 0) lines.push("  (none)");
   for (const report of reports) {
-    lines.push(`  -> [${report.subject}] ${new Date(report.timestamp).toLocaleString()}`, ...indent(cap(report.body)), "");
+    const archive = report.archived ? " · archived after shutdown" : "";
+    lines.push(`  ->${archive} [${report.subject}] ${new Date(report.timestamp).toLocaleString()}`, ...indent(cap(report.body)), "");
   }
 
   const peer = readPeerMail(name);
@@ -225,7 +233,10 @@ function buildTeammateDetail(name: string): string[] {
   if (peer.length === 0) lines.push("  (none)");
   for (const mail of peer) {
     const arrow = mail.direction === "sent" ? `to @${mail.counterpart}` : `from @${mail.counterpart}`;
-    lines.push(`  ${arrow} [${mail.subject}] ${new Date(mail.timestamp).toLocaleString()}`, ...indent(cap(mail.body)), "");
+    const routing = mail.direction === "sent"
+      ? getPeerDeliveryState(mail.id) ?? "written"
+      : "received";
+    lines.push(`  ${arrow} · ${routing} [${mail.subject}] ${new Date(mail.timestamp).toLocaleString()}`, ...indent(cap(mail.body)), "");
   }
   return lines;
 }
@@ -239,7 +250,8 @@ function buildTaskDetail(taskId: string): string[] {
     `[${task.id}] ${task.subject}`,
     "",
     "== task ==",
-    `  Status: ${task.status}${task.claimedBy ? ` (@${task.claimedBy})` : ""}`,
+    `  Status: ${task.status}${task.claimedBy ? ` (@${task.claimedBy})` : ""}${task.supersededBy ? ` → superseded by ${task.supersededBy}` : ""}`,
+    ...((task.resources?.length ?? 0) > 0 ? [`  Resources: ${task.resources.join(", ")}`] : []),
     ...(task.description ? [`  Description:`, ...indent(cap(task.description))] : []),
     ...(task.dependsOn.length > 0
       ? [`  Depends on: ${task.dependsOn.join(", ")} (${task.dependsOn.every((dep) => byId.get(dep)?.status === "completed") ? "met" : "unmet"})`]
@@ -406,7 +418,6 @@ export function openTeamConsole(ctx: {
 
     const renderPicker = (width: number): string[] => {
       if (!picker) return [];
-      const border = style.border("─".repeat(Math.max(1, width)));
       const results = picker.results();
       const selected = picker.selectedIndex();
       if (selected < pickerOffset) pickerOffset = selected;
@@ -427,16 +438,19 @@ export function openTeamConsole(ctx: {
         const display = model.name && model.name !== model.id ? style.dim(model.name) : "";
         return truncateToWidth(`${marker}${theme.fg("customMessageText", modelLabel(model))} ${display} ${tags}`.replace(/\s+$/g, ""), Math.max(10, width - 1));
       });
-      return [
-        border,
-        style.accent(truncateToWidth(`teammate model  ${teamDefault ?? "auto (Pi default)"}`, width)),
-        "",
-        truncateToWidth(`${style.accent("❯ ")}${picker.query()}▏  ${style.dim(`${results.length} models`)}`, Math.max(10, width - 1)),
-        ...rows,
-        "",
-        truncateToWidth(style.dim("type to filter · ↑↓ select · enter set/clear · esc cancel"), Math.max(10, width - 1)),
-        border,
-      ];
+      return renderPiPanel({
+        width,
+        style,
+        fit: truncateToWidth,
+        title: `teammate model  ${teamDefault ?? "auto (Pi default)"}`,
+        body: [
+          "",
+          `${style.accent("❯ ")}${picker.query()}▏  ${style.dim(`${results.length} models`)}`,
+          ...rows,
+          "",
+        ],
+        footer: "type to filter · ↑↓ select · enter set/clear · esc cancel",
+      });
     };
 
     function handlePickerInput(data: string): void {
@@ -456,10 +470,10 @@ export function openTeamConsole(ctx: {
         if (!picked) return;
         if (isClearEntry(picked)) {
           setTeamDefaultModel(undefined);
-          ctx.ui.notify("Teammate model cleared — Pi picks its default", "info");
+          notifyPi(ctx.ui, "Teammate model cleared — Pi picks its default", "info");
         } else {
           setTeamDefaultModel(modelLabel(picked));
-          ctx.ui.notify(`Teammate model set to ${modelLabel(picked)} for this session`, "info");
+          notifyPi(ctx.ui, `Teammate model set to ${modelLabel(picked)} for this session`, "info");
         }
         closeModelPicker();
         return;
@@ -494,7 +508,7 @@ export function openTeamConsole(ctx: {
     const headerLine = (): string => {
       const alive = livingTeammates();
       const tasks = listTasks();
-      return `team  ${alive.length} alive · ${alive.filter(isWorking).length} working · ${getRoles().length} roles · board ${tasks.filter((task) => task.status === "pending").length}p/${tasks.filter((task) => task.status === "claimed").length}c/${tasks.filter((task) => task.status === "completed").length}d · model ${getTeamDefaultModel() ?? "auto"} · ${page}`;
+      return `team  ${alive.length} alive · ${alive.filter(isWorking).length} working · ${getRoles().length} roles · board ${tasks.filter((task) => task.status === "pending").length}p/${tasks.filter((task) => task.status === "claimed").length}c/${tasks.filter((task) => task.status === "completed").length}d/${tasks.filter((task) => task.status === "superseded").length}s · model ${getTeamDefaultModel() ?? "auto"} · ${page}`;
     };
 
     interface ContentLine {
@@ -537,9 +551,11 @@ export function openTeamConsole(ctx: {
       const holder = task.claimedBy ? style.dim(` @${task.claimedBy}`) : "";
       const statusText = task.status === "completed"
         ? style.success("✓")
-        : task.status === "claimed"
-          ? theme.fg("warning", "◐ claimed")
-          : style.dim("○ pending");
+        : task.status === "superseded"
+          ? style.dim("⊘ superseded")
+          : task.status === "claimed"
+            ? theme.fg("warning", "◐ claimed")
+            : style.dim("○ pending");
       return `${marker}${label} ${statusText} ${theme.fg("customMessageText", task.subject)}${holder}`;
     };
 
@@ -573,7 +589,6 @@ export function openTeamConsole(ctx: {
     const listViewport = (): number => Math.max(1, tui.terminal.rows - LIST_CHROME_LINES);
 
     const renderList = (width: number): string[] => {
-      const border = style.border("─".repeat(Math.max(1, width)));
       const content = buildContent();
       const viewport = listViewport();
       const selection = currentPageSelection(currentRows().length);
@@ -588,16 +603,14 @@ export function openTeamConsole(ctx: {
         : style.dim(page === "roster"
             ? "↑↓ select · enter open · tab board · x shutdown · m model · esc/q close"
             : "↑↓ select · enter open · tab roster · esc/q close");
-      return [
-        border,
-        style.accent(truncateToWidth(headerLine(), width)),
-        "",
-        ...content.slice(listOffset, listOffset + viewport)
-          .map((line) => truncateToWidth(line.text, Math.max(10, width - 1))),
-        "",
-        truncateToWidth(footer, Math.max(10, width - 1)),
-        border,
-      ];
+      return renderPiPanel({
+        width,
+        style,
+        fit: truncateToWidth,
+        title: headerLine(),
+        body: content.slice(listOffset, listOffset + viewport).map((line) => line.text),
+        footer,
+      });
     };
 
     const currentPageSelection = (rowCount: number): number => {
@@ -609,20 +622,16 @@ export function openTeamConsole(ctx: {
       detailKind === "task" ? `[${detailKey}]` : detailKind === "role" ? `@${detailKey} · role` : `@${detailKey}`;
 
     const renderDetail = (width: number): string[] => {
-      const border = style.border("─".repeat(Math.max(1, width)));
       const source = detailSource();
       const detail = windowLines(source, width);
-      const footer = style.dim(`  ${detail.range} · ↑↓ scroll · pgup/pgdn page · home/end jump · esc back · q close`);
-      const lines = [
-        border,
-        style.accent(truncateToWidth(`agent-teams  ${detailTitle()}`, width)),
-        "",
-        ...detail.lines.map((line) => `  ${line}`),
-        "",
-        footer,
-        border,
-      ];
-      return lines.map((line) => truncateToWidth(line, Math.max(10, width - 1)));
+      return renderPiPanel({
+        width,
+        style,
+        fit: truncateToWidth,
+        title: `agent-teams  ${detailTitle()}`,
+        body: detail.lines,
+        footer: `${detail.range} · ↑↓ scroll · pgup/pgdn page · home/end jump · esc back · q close`,
+      });
     };
 
     const detailSource = (): string[] => {
@@ -685,7 +694,7 @@ export function openTeamConsole(ctx: {
           if (ctx.modelRegistry && ctx.modelRegistry.getAvailable().length > 0) {
             openModelPicker();
           } else {
-            ctx.ui.notify("No models are available in the model registry.", "warning");
+            notifyPi(ctx.ui, "No models are available in the model registry.", "warning");
           }
           return;
         }
@@ -753,8 +762,8 @@ export function openTeamConsole(ctx: {
 
 async function shutdownFromConsole(ctx: { ui: ExtensionUIContext }, name: string): Promise<void> {
   const result = await shutdownTeammate(name);
-  if (result.ok) ctx.ui.notify(result.body, "info");
-  else ctx.ui.notify(result.error, "error");
+  if (result.ok) notifyPi(ctx.ui, result.body, "info");
+  else notifyPi(ctx.ui, result.error, "error");
 }
 
 function clampIndex(index: number, rowCount: number): number {

package/src/worker.ts

@@ -6,7 +6,9 @@
 
 import { randomUUID } from "node:crypto";
 import * as path from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+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 { appendInboxMessage, appendWorkerEvent, createTaskIntent, readBoardFile, readRoster } from "./statefile.ts";
 import {
@@ -19,6 +21,46 @@ import {
   type BoardTask,
 } from "./types.ts";
 
+const BOARD_DISCLOSURE_TOOLS = ["task_list", "task_claim", "task_submit"] as const;
+type BoardDisclosure = "none" | "notice" | "claimed";
+
+export interface WorkerToolDisclosure {
+  update(prompt: string): void;
+  reset(): void;
+}
+
+function createWorkerToolDisclosure(pi: ExtensionAPI): WorkerToolDisclosure {
+  let state: BoardDisclosure = "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"
+      ? ["task_list", "task_claim"]
+      : state === "claimed"
+        ? ["task_submit"]
+        : [];
+    pi.setActiveTools([...withoutBoardControls, ...revealed]);
+  };
+  return {
+    update(prompt) {
+      const binding = workerBinding();
+      const rosterEntry = binding
+        ? readRoster(binding.rosterFile).find((entry) => entry.name === binding.worker)
+        : undefined;
+      const assignment = rosterEntry?.assignment;
+      if (assignment?.kind === "board" && !assignment.closed) state = "claimed";
+      else if (!assignment && prompt.includes("=== BOARD NOTICE ===")) state = "notice";
+      else state = "none";
+      apply();
+    },
+    reset() {
+      state = "none";
+      apply();
+    },
+  };
+}
+
 export interface WorkerBinding {
   worker: string;
   spawnId: string;
@@ -63,18 +105,54 @@ function dependenciesMet(task: BoardTask, tasks: Map<string, BoardTask>): boolea
   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 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 {
+  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.`;
+  }
+  const conflict = readRoster(binding.rosterFile).find((entry) => entry.name !== binding.worker
+    && entry.assignment && !entry.assignment.closed
+    && resourcesConflict(task.resources, entry.assignment.resources));
+  if (conflict) {
+    return `Task "${task.id}" conflicts with @${conflict.name}'s ${conflict.assignment?.kind} assignment "${conflict.assignment?.id}".`;
+  }
+  return undefined;
+}
+
+function taskStatusLabel(task: BoardTask, tasks: Map<string, BoardTask>): string {
+  if (task.status === "pending") return dependenciesMet(task, tasks) ? "pending/claimable" : "pending/blocked";
+  return task.status;
+}
+
 export function renderTaskBoard(tasks: BoardTask[]): string {
-  if (tasks.length === 0) return "(the task board is empty)";
   const byId = new Map(tasks.map((task) => [task.id, task]));
-  return tasks.map((task) => {
+  const lines = [`BOARD · 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) {
     const deps = task.dependsOn.length > 0
-      ? ` | depends on ${task.dependsOn.join(", ")} (${dependenciesMet(task, byId) ? "met" : "unmet"})`
+      ? ` · depends=${task.dependsOn.join(",")} (${dependenciesMet(task, byId) ? "met" : "blocked"})`
       : "";
-    const holder = task.claimedBy ? ` by @${task.claimedBy}` : "";
-    const verify = task.verify ? ` | verify: ${task.verify}` : "";
-    const description = task.description ? `\n    ${task.description.slice(0, 2000)}` : "";
-    return `- [${task.id}] ${task.status}${holder}: ${task.subject}${deps}${verify}${description}`;
-  }).join("\n");
+    const holder = task.claimedBy ? ` · claimant=@${task.claimedBy}` : "";
+    lines.push(`- ${task.id} · ${taskStatusLabel(task, byId)} · ${task.subject}${holder}${deps}`);
+  }
+  return lines.join("\n");
+}
+
+function renderRoster(roster: string): string {
+  return `ROSTER\n${roster || "(none)"}`;
 }
 
 /** One registration shared by leader and worker; binding chooses the data source. */
@@ -83,8 +161,18 @@ export function registerTaskListTool(pi: ExtensionAPI): void {
     name: "task_list",
     promptSnippet: "Read the shared task board",
     label: "Task Board",
-    description: "Read board tasks with status, dependencies, and verify gates. Pending tasks with met dependencies are claimable.",
+    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();
@@ -92,21 +180,41 @@ export function registerTaskListTool(pi: ExtensionAPI): void {
       const roster = binding
         ? readRoster(binding.rosterFile)
             .filter((entry) => entry.status !== "stopped")
-            .map((entry) => `@${entry.name} (${entry.agent}, ${entry.status})`)
+            .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");
-      return { content: [{ type: "text", text: `${renderTaskBoard(tasks)}\n\nRoster:\n${roster || "(none)"}` }], details: {} };
+      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 },
+      };
     },
   });
 }
 
-export function registerWorkerCapabilities(pi: ExtensionAPI): void {
+export function registerWorkerCapabilities(pi: ExtensionAPI): WorkerToolDisclosure {
+  const disclosure = createWorkerToolDisclosure(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,
+    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(
+        "message",
+        detailField<"steered" | "queued">(result.details, "outcome") ?? "queued",
+        { label: `to @${to}` },
+      ));
+    },
     async execute(_toolCallId, params) {
       const binding = workerBinding();
       if (!binding) throw new Error("This capability is available only inside a spawned teammate.");
@@ -118,10 +226,15 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
           spawnId: binding.spawnId,
           body: params.message,
           status: params.status,
+          timestamp: Date.now(),
         });
-        return { content: [{ type: "text", text: params.status
-          ? "Queued message to leader."
-          : 'Queued message to leader. Note: without status="completed" or status="failed" this report does not end your assignment.' }], details: {} };
+        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",
+        };
       }
       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.");
@@ -135,7 +248,10 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
         subject: messageTitle(params.message),
         body: params.message,
       });
-      return { content: [{ type: "text", text: `Delivered to @${params.to}'s inbox.` }], details: {} };
+      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" },
+      };
     },
   });
 
@@ -143,6 +259,16 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
 
   pi.registerTool({
     name: "task_claim",
+    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" },
+      ));
+    },
     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.",
@@ -160,6 +286,11 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
       }
       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,
@@ -167,7 +298,10 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
           timestamp: Date.now(),
         });
         if (won) {
-          return { content: [{ type: "text", text: `You won [${task.id}] "${task.subject}". Submit with task_submit.` }], details: {} };
+          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.`);
       }
@@ -177,6 +311,17 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
 
   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.",
@@ -193,7 +338,25 @@ export function registerWorkerCapabilities(pi: ExtensionAPI): void {
         timestamp: Date.now(),
       });
       if (!won) throw new Error(`A submission for "${params.taskId}" is already pending.`);
-      return { content: [{ type: "text", text: `Submitted ${params.status} for [${params.taskId}].` }], details: {} };
+      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) },
+      };
     },
   });
+
+  return disclosure;
 }

package/src/worktree.ts

@@ -4,7 +4,8 @@
  *
  * Layout: `<repoRoot>/.pi/worktrees/teammate-<taskId>/`, branch
  * `teammate/<taskId>`. On completion the worker's diff is captured against
- * the base commit, then the worktree and branch are removed.
+ * the base commit, then the worktree directory is removed while the branch
+ * stays so captured work remains retrievable.
  */
 
 import { execFileSync, spawnSync } from "node:child_process";
@@ -104,15 +105,50 @@ export function captureWorktreeDiff(setup: WorktreeSetup): WorktreeDiffResult {
 }
 
 /**
- * Remove the worktree and its branch. Errors are returned rather than thrown
- * so task completion is never blocked by cleanup failure.
+ * Commit any remaining worktree changes onto the branch. Staging alone dies
+ * with the worktree directory; only a commit makes the kept branch carry the
+ * captured work. A clean tree succeeds without a commit.
  */
-export function cleanupWorktree(setup: WorktreeSetup): { ok: boolean; error?: string } {
-  const remove = runGit(setup.repoRoot, ["worktree", "remove", "--force", setup.path]);
-  const branch = runGit(setup.repoRoot, ["branch", "-D", setup.branch]);
+function commitRemainingWork(setup: WorktreeSetup): { ok: boolean; error?: string } {
+  const add = runGit(setup.path, ["add", "-A"]);
+  if (add.status !== 0) return { ok: false, error: add.stderr.trim() || "git add failed" };
+  const result = spawnSync("git", ["-C", setup.path, "commit", "-m", "agent-teams: capture teammate work"], { encoding: "utf-8" });
+  if (result.status === 0) return { ok: true };
+  const output = `${result.stderr ?? ""}${result.stdout ?? ""}`;
+  if (/nothing to commit/i.test(output)) return { ok: true };
+  return { ok: false, error: output.trim() || "git commit failed" };
+}
+
+/**
+ * Remove the worktree directory but keep the branch: remaining changes are
+ * committed first so the captured diff stays retrievable with
+ * `git diff <baseCommit>..<branch>` after cleanup. Pass `{ deleteBranch: true }`
+ * for teardowns where no work was captured (a failed spawn). When the commit
+ * fails in keep-branch mode the directory is PRESERVED and returned in the
+ * error — removing it would destroy the only copy of the work. Errors are
+ * returned rather than thrown so task completion is never blocked by cleanup
+ * failure.
+ */
+export function cleanupWorktree(
+  setup: WorktreeSetup,
+  options?: { deleteBranch?: boolean },
+): { ok: boolean; error?: string } {
   const errors: string[] = [];
+  if (!options?.deleteBranch) {
+    const commit = commitRemainingWork(setup);
+    if (!commit.ok) {
+      return {
+        ok: false,
+        error: `commit: ${commit.error}; worktree left in place at ${setup.path} so the work is not lost`,
+      };
+    }
+  }
+  const remove = runGit(setup.repoRoot, ["worktree", "remove", "--force", setup.path]);
   if (remove.status !== 0) errors.push(`worktree remove: ${remove.stderr.trim()}`);
-  if (branch.status !== 0) errors.push(`branch delete: ${branch.stderr.trim()}`);
+  if (options?.deleteBranch) {
+    const branch = runGit(setup.repoRoot, ["branch", "-D", setup.branch]);
+    if (branch.status !== 0) errors.push(`branch delete: ${branch.stderr.trim()}`);
+  }
   try {
     runGit(setup.repoRoot, ["worktree", "prune"]);
   } catch {
@@ -121,7 +157,8 @@ export function cleanupWorktree(setup: WorktreeSetup): { ok: boolean; error?: st
   return errors.length > 0 ? { ok: false, error: errors.join("; ") } : { ok: true };
 }
 
-/** Best-effort cleanup used when a spawn fails before the worker starts. */
+/** Best-effort cleanup used when a spawn fails before the worker starts:
+ *  nothing was captured, so the empty branch goes too. */
 export function discardWorktree(setup: WorktreeSetup): void {
-  cleanupWorktree(setup);
+  cleanupWorktree(setup, { deleteBranch: true });
 }