@fradser/pi-agent-teams 0.9.2 → 1.0.0

package/src/tool-copy.ts

@@ -9,12 +9,13 @@
  */
 
 import { contentDetailLines, detailField, displayText, fieldBlock, fieldLine, safeDisplayText, scrubHandles } from "@fradser/pi-kit";
-import { resolveAgent } from "./agents.ts";
+import { resolveAgent } from "@fradser/pi-subagents";
 import { runningTeammateActivity } from "./activity.ts";
 import { parseExactSessionRoute } from "./recipient.ts";
-import { getTask, getTeammate } from "./state.ts";
-import { resolveWorkerTools } from "./spawner.ts";
-import type { BoardTask, Teammate } from "./types.ts";
+import { getTask, getAgent } from "./state.ts";
+import { resolveAgentTools } from "@fradser/pi-subagents";
+import { WORKER_CAPABILITY_TOOLS } from "./capability-tools.ts";
+import type { Task, Agent } from "./types.ts";
 
 /** One rendered lifecycle row: the collapsed line plus its expanded body. */
 export interface CoordinationRow {
@@ -24,10 +25,6 @@ export interface CoordinationRow {
   body: string[];
 }
 
-const COLLAPSED_TASK_LIMIT = 90;
-/** A kickoff prompt is shown in full up to this size, then clipped. */
-const FIELD_LIMIT = 2000;
-
 /** Package resolver: a known Work handle becomes its subject. Only prefixed
  * handles are machine identifiers; a bare UUID can be a person's own text
  * (a commit, an id under review) and survives verbatim inside kit. */
@@ -55,11 +52,12 @@ function clipLines(value: unknown): string {
   return displayText(value).split("\n").map((line) => plainText(line)).join("\n");
 }
 
-function shortTask(value: unknown): string {
+/** The first non-empty line, on one line: a title. The row's own width fit
+ * bounds it and expansion reveals the whole value, so no character cap here. */
+function headline(value: unknown): string {
   const text = displayText(value);
   const firstLine = text.split("\n").map((l) => plainText(l).trim()).find(Boolean) ?? "";
-  const line = collapse(firstLine);
-  return line.length <= COLLAPSED_TASK_LIMIT ? line : `${line.slice(0, COLLAPSED_TASK_LIMIT - 1).trimEnd()}…`;
+  return collapse(firstLine);
 }
 
 /** Array fields also arrive untyped from a model call. */
@@ -72,8 +70,8 @@ function labeled(label: string, value: unknown): string {
 }
 
 /** Multi-line field: the label heads the first line, the rest follow verbatim. */
-function labeledBlock(label: string, value: unknown, limit = FIELD_LIMIT): string[] {
-  return fieldBlock(label, clipLines(value), limit);
+function labeledBlock(label: string, value: unknown): string[] {
+  return fieldBlock(label, clipLines(value));
 }
 
 function bodyLines(value: unknown): string[] {
@@ -94,7 +92,7 @@ const STATUS_WORDS: Record<string, string> = {
   idle: "idle",
   stopped: "stopped",
   pending: "pending",
-  claimed: "claimed",
+  in_progress: "in progress",
   completed: "completed",
   superseded: "superseded",
   sent: "sent",
@@ -114,11 +112,11 @@ function stateWord(value: unknown): string {
   return STATUS_WORDS[key] ?? key.replace(/[_-]+/g, " ");
 }
 
-function workOf(teammate: Teammate | undefined, task?: BoardTask): string | undefined {
+function workOf(teammate: Agent | undefined, task?: Task): string | undefined {
   const source = task ?? (teammate?.workId ? getTask(teammate.workId) : undefined);
   if (!source) return undefined;
   const owner = source.claimedBy ? ` · @${source.claimedBy}` : "";
-  return `${shortTask(source.subject)} · ${stateWord(source.status)}${owner}`;
+  return `${headline(source.subject)} · ${stateWord(source.status)}${owner}`;
 }
 
 // ── agent ─────────────────────────────────────────────────────────
@@ -137,9 +135,6 @@ export interface AgentRowArgs {
     tools?: string[];
     model?: string;
     verify?: string;
-    worktree?: boolean;
-    persist?: boolean;
-    persistScope?: string;
   };
 }
 
@@ -152,15 +147,13 @@ function agentName(args: AgentRowArgs, details: unknown): string {
 function roleLine(args: AgentRowArgs, name: string): string | undefined {
   const generated = args.definition;
   if (generated?.description) {
-    return generated.persist
-      ? `${oneLine(generated.description)} · saved as ${generated.persistScope ?? "project-local"} role`
-      : `${oneLine(generated.description)} · new role for this session`;
+    return `${oneLine(generated.description)} · new role for this session`;
   }
   const resolved = resolveAgent(name);
   return resolved ? `${oneLine(resolved.description) || "role"} · ${resolved.scope} role` : undefined;
 }
 
-function agentStateWord(args: AgentRowArgs, teammate: Teammate | undefined, details: unknown, flags: { isError?: boolean; isPartial?: boolean }): string {
+function agentStateWord(args: AgentRowArgs, teammate: Agent | undefined, details: unknown, flags: { isError?: boolean; isPartial?: boolean }): string {
   if (flags.isError) return "failed";
   const action = args.action ?? "agent";
   const live = teammate ? stateWord(teammate.status) : undefined;
@@ -187,7 +180,7 @@ export function agentRow(
   flags: { isError?: boolean; isPartial?: boolean } = {},
 ): CoordinationRow {
   const name = agentName(args, details);
-  const teammate = getTeammate(name);
+  const teammate = getAgent(name);
   const action = args.action ?? "agent";
   let task: string | undefined;
   if (action === "delegate") {
@@ -203,7 +196,7 @@ export function agentRow(
       task = getTask(workId)?.subject;
     }
   }
-  const subject = [`@${name}`, agentStateWord(args, teammate, details, flags), task ? shortTask(task) : ""]
+  const subject = [`@${name}`, agentStateWord(args, teammate, details, flags), task ? headline(task) : ""]
     .filter(Boolean)
     .join(" · ");
   return { subject, body: agentBody(args, name, teammate, details, flags) };
@@ -212,7 +205,7 @@ export function agentRow(
 function agentBody(
   args: AgentRowArgs,
   name: string,
-  teammate: Teammate | undefined,
+  teammate: Agent | undefined,
   details: unknown,
   flags: { isError?: boolean },
 ): string[] {
@@ -230,7 +223,7 @@ function agentBody(
     // field would duplicate the header, and could contradict it when the live
     // teammate and the inspected snapshot disagree.
     return [
-      ...(isWorking && teammate ? [labeled("now", shortTask(runningTeammateActivity(teammate)))] : []),
+      ...(isWorking && teammate ? [labeled("now", headline(runningTeammateActivity(teammate)))] : []),
       ...(work && isWorking ? [labeled("work", work)] : []),
       ...(sessionTools ? [labeled("tools", sessionTools.join(", "))] : []),
       ...(warning ? [labeled("warning", warning)] : []),
@@ -241,7 +234,7 @@ function agentBody(
   }
   const role = roleLine(args, name);
   const resources = strings(args.resources);
-  const granted = teammate?.tools ?? resolveWorkerTools(strings(args.definition?.tools).length > 0 ? strings(args.definition?.tools) : resolveAgent(name)?.tools);
+  const granted = teammate?.tools ?? resolveAgentTools(strings(args.definition?.tools).length > 0 ? strings(args.definition?.tools) : resolveAgent(name)?.tools, WORKER_CAPABILITY_TOOLS);
   // The spawn receipt carries the same coordination-only warning as inspection,
   // so delegate and start rows state the narrow grant they actually produced.
   const sessionWarning = detailField<string>(detailField(details, "session"), "warning");
@@ -251,7 +244,6 @@ function agentBody(
     labeled("model", teammate?.model ?? args.model ?? args.definition?.model ?? "team default"),
     labeled("tools", granted.join(", ")),
     ...(sessionWarning ? [labeled("warning", sessionWarning)] : []),
-    ...(teammate?.isolation === "worktree" ? [labeled("isolation", "dedicated git worktree")] : []),
     ...(teammate?.context === "fork" || args.fork ? [labeled("context", "forked from this session")] : []),
     ...(resources.length > 0 ? [labeled("resources", resources.join(", "))] : []),
     ...(() => {
@@ -276,7 +268,7 @@ export function leaderWorkRow(
     const items = Array.isArray(works) ? works : [];
     return {
       subject: `${items.length} work item${items.length === 1 ? "" : "s"}`,
-      body: items.map((item) => `- ${shortTask(item.subject)} · ${stateWord(item.state)}${item.claimedBy ? ` · @${item.claimedBy}` : ""}`),
+      body: items.map((item) => `- ${headline(item.subject)} · ${stateWord(item.state)}${item.claimedBy ? ` · @${item.claimedBy}` : ""}`),
     };
   }
   const work = detailField<{ subject?: string; state?: string; resources?: string[] }>(details, "work");
@@ -293,7 +285,7 @@ export function leaderWorkRow(
   const workResources = strings(detailField<unknown>(work, "resources"));
   const stillRunning = detailField<string>(details, "holderStillRunning");
   return {
-    subject: `${shortTask(subject)} · ${flags.isError ? "failed" : stateWord(outcome)}`,
+    subject: `${headline(subject)} · ${flags.isError ? "failed" : stateWord(outcome)}`,
     body: [
       ...(work?.state ? [labeled("state", stateWord(work.state))] : []),
       ...(stillRunning ? [labeled("risk", `@${stillRunning} was still working; an in-flight batch may still write inside the released scope`)] : []),
@@ -314,7 +306,7 @@ export function leaderWorkRow(
 
 /** One `agent_event` row: who receives it and what was actually said. */
 export function messageRow(
-  args: { to?: string; message?: string; intent?: string },
+  args: { to?: string; body?: string; kind?: string },
   details: unknown,
   options: { isError?: boolean } = {},
 ): CoordinationRow {
@@ -322,7 +314,7 @@ export function messageRow(
   const outcome = detailField<string>(details, "outcome");
   // Messages are literal readbacks, not prose to clean up. Only terminal
   // controls and runtime handles change; the shared renderer owns truncation.
-  const message = scrubHandles(safeDisplayText(displayText(args.message)), workHandle);
+  const message = scrubHandles(safeDisplayText(displayText(args.body)), workHandle);
   const prefix = [`to @${to}`, options.isError ? "failed" : outcome ? stateWord(outcome) : undefined]
     .filter(Boolean).join(" · ");
   return {
@@ -351,7 +343,7 @@ export function workerWorkRow(
       ? "current Work"
       : undefined;
   return {
-    subject: `${shortTask(subject ?? leads ?? "Work")} · ${flags.isError ? "failed" : workerStateWord(action, outcome)}`,
+    subject: `${headline(subject ?? leads ?? "Work")} · ${flags.isError ? "failed" : workerStateWord(action, outcome)}`,
     body: bodyLines(content).slice(1),
   };
 }

package/src/tools.ts

@@ -1,88 +1,26 @@
-import { truncateHead, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { CoordinationToolResult } from "./types.ts";
 import { notifyPi } from "@fradser/pi-kit";
 import {
-  assignExistingWork,
-  releaseExistingWork,
-  reopenExistingWork,
-  createBoardTask,
   publishStateSnapshot,
   sendLeaderMessage,
-  shutdownTeammateExact,
-  spawnTeammate,
+  shutdownAgentExact,
+  spawnAgent,
 } from "./team-machine.ts";
-import { listTasks, livingTeammates } from "./state.ts";
+import { livingAgents } from "./state.ts";
 
-import { AgentActionParams, LEADER_RECIPIENT, AgentEventParams, WorkToolParams, normalizeCoordinationParams, requireParsedParams } from "./types.ts";
+import { AgentEventParams, LEADER_RECIPIENT } from "./types.ts";
 import { openTeamConsole, refreshTeamUI } from "./ui.ts";
-import { discoverAgents } from "./agents.ts";
-import { agentRow, leaderWorkRow, messageRow, type AgentRowArgs } from "./tool-copy.ts";
+import { discoverAgents } from "@fradser/pi-subagents";
+import { messageRow } from "./tool-copy.ts";
 import { emptyToolCall, renderCoordinationRow } from "./tool-render.ts";
-import { runAgentAction, type AgentActionRuntime } from "./agent-actions.ts";
+import type { AgentActionRuntime } from "./agent-actions.ts";
 import { resolveRecipient } from "./recipient.ts";
 
-function formatWorkList(tasks: ReturnType<typeof listTasks>): string {
-  const works = tasks.map((task) => {
-    const dependencies = task.dependsOn.length > 0 ? ` · depends=${task.dependsOn.join(",")}` : "";
-    const holder = task.claimedBy ? ` · owner=@${task.claimedBy}` : "";
-    const result = task.result ? truncateHead(task.result, { maxBytes: 4096, maxLines: 40 }) : undefined;
-    const evidence = result ? `\n  RESULT · ${result.content}${result.truncated ? "\n  [Result preview truncated; complete evidence is retained in Work details.]" : ""}` : "";
-    return `- ${task.id} · ${task.status} · ${task.subject}${holder}${dependencies}${evidence}`;
-  });
-  return [
-    "WORK · current session",
-    `SUMMARY · ${tasks.length} work item${tasks.length === 1 ? "" : "s"}`,
-    "WORK ITEMS",
-    ...(works.length > 0 ? works : ["(none)"]),
-  ].join("\n");
-}
-
-function formatWorkCreation(subject: string, created: {
-  id: string;
-  claimable: boolean;
-  resourceBlocked: boolean;
-  notifiedTeammates: string[];
-}): string {
-  const availability = created.claimable ? "pending/claimable" : "pending/blocked";
-  const routing = created.notifiedTeammates.length > 0
-    ? `eligible residents notified: ${created.notifiedTeammates.map((name) => `@${name}`).join(", ")}`
-    : created.resourceBlocked
-      ? "resource conflict blocks assignment"
-      : "no eligible resident notified";
-  return [
-    "WORK · current session",
-    `CREATED · ${created.id} · ${availability} · ${subject}`,
-    `ROUTING · ${routing}`,
-  ].join("\n");
-}
-
-export function registerLeaderTools(pi: ExtensionAPI, runtime: AgentActionRuntime & { sendLeaderMessage: typeof sendLeaderMessage } = { spawnTeammate, shutdownTeammateExact, sendLeaderMessage }): void {
-  pi.registerTool({
-    name: "agent",
-    promptSnippet: "Delegate, start, inspect, or stop an Agent session",
-    label: "Agent",
-    description: "Strict Agent lifecycle interface. Delegate creates independent Work; start creates an unassigned resident; inspect and stop use incarnation-bound session handles. Results arrive automatically; inspect is for deliberate diagnosis, not waiting.",
-    promptGuidelines: ["After agent delegation, results arrive automatically. Continue independent work or end the turn; do not wait with sleep, repeated agent inspect, or work list polling."],
-    parameters: AgentActionParams,
-    renderShell: "self",
-    renderCall: emptyToolCall,
-    renderResult(result, options, theme, context) {
-      return renderCoordinationRow(
-        result, options, theme, context,
-        "agent",
-        agentRow(context.args as AgentRowArgs, result.details, { isError: context.isError, isPartial: options.isPartial }),
-      );
-    },
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await runAgentAction(params as Parameters<typeof runAgentAction>[0], ctx.cwd, runtime, ctx.sessionManager);
-      if (params.action !== "inspect") {
-        refreshTeamUI(ctx);
-      }
-      return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
-    },
-  });
-
+/** Point-to-point communication. Stays with @fradser/pi-agent-teams. */
+export function registerMessageTool(pi: ExtensionAPI, runtime: { sendLeaderMessage: typeof sendLeaderMessage } = { sendLeaderMessage }): void {
   pi.registerTool({
-    name: "agent_event",
+    name: "message",
     promptSnippet: "Send an event or message to a participant",
     label: "Agent Event",
     description: "Shared communication interface across Leader, Worker, and Peers. Leader-to-Agent messages carry only new evidence, changed constraints, or decisions — never kickoff echoes, progress requests, completion requests, or confirmation probes.",
@@ -93,152 +31,61 @@ export function registerLeaderTools(pi: ExtensionAPI, runtime: AgentActionRuntim
       return renderCoordinationRow(
         result, options, theme, context,
         "message",
-        messageRow(context.args as { to?: string; message?: string }, result.details, { isError: context.isError }),
+        messageRow(context.args as { to?: string; body?: string }, result.details, { isError: context.isError }),
       );
     },
     async execute(_toolCallId, params) {
+      // A refusal is returned, not thrown, so every tool in the coordination
+      // surface reports failure the same way and a caller reads one shape
+      // whatever went wrong. Throwing here would make `message` the only tool
+      // that needs a try/catch.
+      const refuse = (error: string): CoordinationToolResult => ({
+        content: [{ type: "text", text: error }],
+        details: { ok: false, error },
+        isError: true,
+      });
       if (!params.to) {
-        throw new Error("No bound reply route exists. Please specify 'to' explicitly.");
+        return refuse("No bound reply route exists. Please specify 'to' explicitly.");
       }
-      if (params.to === LEADER_RECIPIENT) throw new Error("The leader cannot send an event to itself.");
-      const to = resolveRecipient(params.to, livingTeammates()).name;
-      const result = runtime.sendLeaderMessage(to, params.message, {});
-      if (!result.ok) throw new Error(result.error);
-      const recorded = result.outcome === "not-sent" ? `\nRECORDED TERMINAL REPORT · ${result.terminalReport}` : "";
-      const next = "";
-      return {
-        content: [{ type: "text", text: `EVENT ROUTING · ${result.outcome} · to=@${to}\nINTENT · ${params.intent ?? "inform"}${recorded}${next}` }],
-        details: { to, outcome: result.outcome, intent: params.intent ?? "inform" },
-      };
-    },
-  });
-
-  pi.registerTool({
-    name: "work",
-    promptSnippet: "Create, list, assign, release, reopen, or supersede Work Items",
-    label: "Work",
-    description: "Manage Work Items: create (subject), list, assign (id, target.session), release (id, reason), reopen (id, reason), or supersede (subject, supersedes). Creation uses the session's single-writer Work state and never starts a resident.",
-    parameters: WorkToolParams,
-    renderShell: "self",
-    renderCall: emptyToolCall,
-    renderResult(result, options, theme, context) {
-      return renderCoordinationRow(
-        result, options, theme, context,
-        "work",
-        leaderWorkRow(context.args as Record<string, unknown>, result.details, { isError: context.isError }),
-      );
-    },
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      // Union-root schema: some harnesses deliver target/arrays as JSON strings.
-      params = requireParsedParams(normalizeCoordinationParams(params as Record<string, unknown>, ["target", "dependsOn", "resources", "supersedes"]), ["target", "dependsOn", "resources", "supersedes"]) as typeof params;
-      if (params.action === "supersede") {
-        const tasks = listTasks();
-        const referenced = [...((params.dependsOn as string[] | undefined) ?? []), ...(params.supersedes as string[])];
-        if (referenced.some((id) => !tasks.some((task) => task.id === id))) {
-          throw new Error(`Unknown work id in [${referenced.join(", ")}].`);
-        }
-        const created = createBoardTask(params as Parameters<typeof createBoardTask>[0]);
-        if (!created.ok) throw new Error(created.error);
-        const work = listTasks().find((task) => task.id === created.id);
-        if (!work) throw new Error(`Replacement Work Item "${created.id}" is unavailable.`);
-        refreshTeamUI(ctx);
-        return {
-          content: [{ type: "text", text: `WORK · current session\nSUPERSEDED · ${work.id} · ${work.status}\nREPLACED · ${created.supersededTaskIds.join(", ")}\nROUTING · ${created.notifiedTeammates.length > 0 ? `eligible residents notified: ${created.notifiedTeammates.map((name) => `@${name}`).join(", ")}` : "no eligible resident notified"}` }],
-          details: {
-            action: "supersede", outcome: "superseded", state: work.status,
-            work: { id: work.id, subject: work.subject, ...(work.description ? { description: work.description } : {}), dependsOn: work.dependsOn, resources: work.resources, ...(work.verify ? { verify: work.verify } : {}), state: work.status },
-            supersededWorkIds: created.supersededTaskIds, notifiedTeammates: created.notifiedTeammates, claimable: created.claimable,
-          },
-        };
-      }
-      if (params.action === "reopen") {
-        const reopened = reopenExistingWork(params.id);
-        if (!reopened.ok) throw new Error(reopened.error);
-        refreshTeamUI(ctx);
-        return {
-          content: [{ type: "text", text: `WORK · current session\nREOPENED · ${reopened.workId} · pending\nREASON · ${params.reason}` }],
-          details: { action: "reopen", outcome: "reopened", state: "pending", work: { id: reopened.workId, subject: reopened.subject, resources: reopened.resources, state: "pending" }, reason: params.reason },
-        };
-      }
-      if (params.action === "release") {
-        const released = releaseExistingWork(params.id, params.reason);
-        if (!released.ok) throw new Error(released.error);
-        refreshTeamUI(ctx);
-        const residual = released.holderStillRunning
-          ? `\nRISK · @${released.holderStillRunning} was still working; an in-flight tool batch may still write inside ${released.resources.join(", ") || "the released scope"}.`
-          : "";
-        return {
-          content: [{ type: "text", text: `WORK · current session\nRELEASED · ${released.workId} · pending\nREASON · ${params.reason}${residual}` }],
-          details: { action: "release", outcome: "released", state: "pending", work: { id: released.workId, subject: released.subject, resources: released.resources, state: "pending" }, reason: params.reason, ...(released.holderStillRunning ? { holderStillRunning: released.holderStillRunning } : {}) },
-        };
-      }
-      if (params.action === "assign") {
-        const assigned = assignExistingWork(params.id, (params.target as { session: string }).session);
-        if (!assigned.ok) throw new Error(assigned.error);
-        const task = listTasks().find((entry) => entry.id === assigned.workId);
-        if (!task) throw new Error(`Assigned Work Item "${assigned.workId}" is unavailable.`);
-        refreshTeamUI(ctx);
-        return {
-          content: [{ type: "text", text: `WORK · current session\nASSIGNED · ${task.id} · claimed · owner=@${assigned.owner}\nATTEMPT · ${assigned.assignmentId} · fresh-session-pending` }],
-          details: {
-            action: "assign", outcome: "assigned", state: task.status,
-            work: { id: task.id, subject: task.subject, resources: task.resources, state: task.status, claimedBy: task.claimedBy },
-            assignment: { id: assigned.assignmentId, owner: assigned.owner, kind: "direct" },
-            target: params.target as { session: string }, delivery: "fresh-session-pending",
-          },
-        };
-      }
-      if (params.action === "list") {
-        const works = listTasks().map((task) => ({
-          id: task.id,
-          subject: task.subject,
-          ...(task.description ? { description: task.description } : {}),
-          dependsOn: task.dependsOn,
-          resources: task.resources,
-          ...(task.verify ? { verify: task.verify } : {}),
-          state: task.status,
-          ...(task.claimedBy ? { claimedBy: task.claimedBy } : {}),
-          ...(task.result ? { result: task.result } : {}),
-        }));
-        return {
-          content: [{ type: "text", text: formatWorkList(listTasks()) }],
-          details: { action: "list", outcome: "listed", works, count: works.length },
-        };
+      if (params.to === LEADER_RECIPIENT) return refuse("The leader cannot send a message to itself.");
+      let to: string;
+      try {
+        to = resolveRecipient(params.to, livingAgents()).name;
+      } catch (error) {
+        return refuse(error instanceof Error ? error.message : String(error));
       }
-      const tasks = listTasks();
-      const referenced = (params.dependsOn as string[] | undefined) ?? [];
-      if (referenced.some((id) => !tasks.some((task) => task.id === id))) {
-        throw new Error(`Unknown work id in [${referenced.join(", ")}].`);
-      }
-      const created = createBoardTask(params as Parameters<typeof createBoardTask>[0]);
-      if (!created.ok) throw new Error(created.error);
-      const work = listTasks().find((task) => task.id === created.id);
-      if (!work) throw new Error(`Created Work Item "${created.id}" is unavailable.`);
-      refreshTeamUI(ctx);
+      const result = runtime.sendLeaderMessage(to, params.body, {});
+      if (!result.ok) return refuse(result.error);
+      const recorded = result.outcome === "not-sent" ? `\nRECORDED TERMINAL REPORT · ${result.terminalReport}` : "";
       return {
-        content: [{ type: "text", text: formatWorkCreation(params.subject, created) }],
-        details: {
-          action: "create",
-          outcome: "created",
-          state: work.status,
-          work: {
-            id: work.id,
-            subject: work.subject,
-            ...(work.description ? { description: work.description } : {}),
-            dependsOn: work.dependsOn,
-            resources: work.resources,
-            ...(work.verify ? { verify: work.verify } : {}),
-            state: work.status,
-          },
-          notifiedTeammates: created.notifiedTeammates,
-          claimable: created.claimable,
-          supersededWorkIds: created.supersededTaskIds,
-        },
+        content: [{ type: "text", text: `MESSAGE ROUTING · ${result.outcome} · to=@${to}\nKIND · ${params.kind ?? "inform"}${recorded}` }],
+        details: { to, outcome: result.outcome, kind: params.kind ?? "inform", ok: true },
       };
     },
   });
+}
 
+// The `task` tool is registered by @fradser/pi-tasks' own extension entry. This
+// package loads it through its manifest rather than calling its registrar, so
+// there is exactly one registrant of that tool in every install combination.
+// The leader learns about tasks transitions on `pi-tasks:*` events instead.
 
+/** Temporary seam. Each registrar moves to its owning package; this keeps the
+ *  existing entry point and its test fixtures intact until that lands. */
+/** Register this package's own tool, and only that one.
+ *
+ * `agent` is registered by @fradser/pi-subagents and `task` by
+ * @fradser/pi-tasks. This package's manifest loads those two extension entries
+ * alongside its own, which is how one install ends up with three tools and each
+ * tool still has exactly one registrant. A tool with two registrants either
+ * collides or is silently dropped depending on load order, and neither failure is
+ * visible from here.
+ *
+ * The leader learns about tasks transitions on `pi-tasks:*` events rather than
+ * being called by pi-tasks, so the domain never has to know a resident exists.
+ */
+export function registerLeaderTools(pi: ExtensionAPI, runtime: AgentActionRuntime & { sendLeaderMessage: typeof sendLeaderMessage } = { spawnAgent, shutdownAgentExact, sendLeaderMessage }): void {
+  registerMessageTool(pi, runtime);
 }
 
 function teamStatusSummary(): string {
@@ -246,13 +93,13 @@ function teamStatusSummary(): string {
   const rolesLine = roles.length > 0
     ? `${roles.length} persistent agent role${roles.length === 1 ? "" : "s"}: ${roles.join(", ")}`
     : "No agent roles discovered.";
-  const roster = livingTeammates().map((t) => `@${t.name} (${t.agent}, ${t.status})`).join("\n") || "No living sessions.";
+  const roster = livingAgents().map((t) => `@${t.name} (${t.role}, ${t.status})`).join("\n") || "No living sessions.";
   return `${roster}\n${rolesLine}`;
 }
 
 export function registerTeamCommand(pi: ExtensionAPI): void {
   pi.registerCommand("agent-teams", {
-    description: "Agent Teams management console: session teammates and persistent agent roles",
+    description: "Agent Teams management console: session agents and persistent agent roles",
     handler: async (_args, ctx) => {
       publishStateSnapshot();
       if (ctx.mode !== "tui") { notifyPi(ctx.ui, teamStatusSummary(), "info"); return; }