@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/pi-intercom/reply-wait.ts

@@ -1,26 +1,14 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
 import type { Message } from "./types.ts";
 import type { IntercomClient, SendResult } from "./broker/client.ts";
 import type { IntercomTransport } from "./transport.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
-import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.ts";
 import { asError } from "./validation.ts";
-import { AskDeliveryError } from "./tool-results.ts";
-import {
-  cancelSupervisorQuestion,
-  readQuestionState,
-  saveQuestionAnswer,
-  type SupervisorQuestion,
-} from "../runs/shared/supervisor-questions.ts";
-
-type Lifecycle = Readonly<Pick<IntercomLifecycle, "live" | "markActivity">>;
+import { AskDeliveryError, RecoveryError } from "./tool-results.ts";
 
+type Lifecycle = Readonly<Pick<IntercomLifecycle, "markActivity">>;
 interface ReplyWaiter {
   readonly from: string;
   readonly replyTo: string;
-  readonly question?: ReadonlyInput<SupervisorQuestion>;
-  readonly retryNotification?: () => void;
   readonly resolve: (message: Message) => void;
   readonly reject: (error: Readonly<Error>) => void;
 }
@@ -28,7 +16,6 @@ export interface ReplyWaitOptions {
   readonly from: string;
   readonly replyTo: string;
   readonly signal?: AbortSignal;
-  readonly question?: ReadonlyInput<SupervisorQuestion>;
 }
 export interface AskTransaction {
   readonly to: string;
@@ -37,46 +24,26 @@ export interface AskTransaction {
   readonly signal?: AbortSignal;
   readonly onSent: (result: SendResult) => void;
 }
-/** Owns the single blocking wait, abort listener, timeout and durable polling. */
+/** One correlated blocking wait; admitted before send so a fast reply cannot race it. */
 export class ReplyWait {
   private waiter: ReplyWaiter | null = null;
-  private readonly pi: ExtensionAPI;
   private readonly lifecycle: Lifecycle;
   private readonly timeoutMs: number;
-  constructor(pi: ExtensionAPI, lifecycle: Lifecycle, timeoutMs: number) {
-    this.pi = pi;
+  constructor(lifecycle: Lifecycle, timeoutMs: number) {
     this.lifecycle = lifecycle;
     this.timeoutMs = timeoutMs;
   }
   get waiting(): boolean {
     return this.waiter !== null;
   }
-  get durable(): boolean {
-    return this.waiter?.question !== undefined;
-  }
   isWaitingFor(id: string): boolean {
     return this.waiter?.replyTo === id;
   }
-  retarget(id: string, from: string): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, from };
-    }
-  }
-  clearRetry(id: string): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, retryNotification: undefined };
-    }
-  }
-  retry(id: string, retryNotification: () => void): void {
-    if (this.waiter?.replyTo === id) {
-      this.waiter = { ...this.waiter, retryNotification };
-    }
-  }
   reject(error: Readonly<Error>): void {
     this.waiter?.reject(error);
   }
   peerDisconnected(id: string): void {
-    if (this.waiter?.from === id && !this.waiter.question) {
+    if (this.waiter?.from === id) {
       this.reject(new Error(`Reply peer disconnected before answering: ${id}`));
     }
   }
@@ -85,65 +52,14 @@ export class ReplyWait {
     message: Message,
     onMatch: () => void,
   ): boolean {
-    const { id: from, name } = sender;
     const waiter = this.waiter;
-    if (!waiter) {
-      return false;
-    }
-    const senderTarget = name !== undefined && name !== "" ? name : from;
-    if (
-      (senderTarget.toLowerCase() !== waiter.from.toLowerCase() && from !== waiter.from) ||
-      message.replyTo !== waiter.replyTo
-    ) {
+    if (!waiter || sender.id !== waiter.from || message.replyTo !== waiter.replyTo) {
       return false;
     }
     onMatch();
     waiter.resolve(message);
     return true;
   }
-  private poll(question: ReadonlyInput<SupervisorQuestion>, replyTo: string): void {
-    try {
-      const saved = readQuestionState(question);
-      if (saved.state === "cancelled") {
-        this.lifecycle.live()?.abort();
-        this.reject(new Error("Cancelled"));
-        return;
-      }
-      if (saved.answer) {
-        this.waiter?.resolve({
-          id: replyTo,
-          replyTo,
-          timestamp: saved.answer.answeredAt,
-          content: { text: saved.answer.message },
-        });
-      } else {
-        this.waiter?.retryNotification?.();
-      }
-    } catch (error) {
-      this.reject(asError(error));
-    }
-  }
-  private saveAnswer(
-    question: ReadonlyInput<SupervisorQuestion> | undefined,
-    message: Message,
-  ): boolean {
-    if (!question) {
-      return true;
-    }
-    if (
-      message.content.attachments?.some(
-        (attachment) => attachment.name === RECIPIENT_TURN_FAILED_ATTACHMENT,
-      ) === true
-    ) {
-      this.pi.appendEntry("intercom_question_notification_error", {
-        questionId: question.questionId,
-        error: message.content.text,
-      });
-      return false;
-    }
-    saveQuestionAnswer(question, message.content.text);
-    return true;
-  }
   wait(options: ReplyWaitOptions): Promise<Message> {
     if (this.waiter) {
       throw new Error("Already waiting for a reply");
@@ -152,56 +68,34 @@ export class ReplyWait {
       throw new Error("Cancelled");
     }
     return new Promise((resolve, reject) => {
-      const { from, replyTo, signal, question } = options;
-      const timeout = question
-        ? undefined
-        : setTimeout(() => {
-            this.reject(
-              new Error(
-                `No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`,
-              ),
-            );
-          }, this.timeoutMs);
-      timeout?.unref();
-      const poll = question
-        ? setInterval(() => {
-            this.poll(question, replyTo);
-          }, 250)
-        : undefined;
+      const { from, replyTo, signal } = options;
+      const timeout = setTimeout(() => {
+        this.reject(
+          new RecoveryError(
+            "reply_timeout",
+            `No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`,
+          ),
+        );
+      }, this.timeoutMs);
+      timeout.unref();
       const cleanup = () => {
         clearTimeout(timeout);
-        clearInterval(poll);
         signal?.removeEventListener("abort", onAbort);
         if (this.waiter?.replyTo === replyTo) {
           this.waiter = null;
         }
       };
       const onAbort = () => {
-        try {
-          if (question) {
-            cancelSupervisorQuestion(question);
-          }
-        } finally {
-          cleanup();
-          reject(new Error("Cancelled"));
-        }
+        cleanup();
+        reject(new Error("Cancelled"));
       };
       signal?.addEventListener("abort", onAbort, { once: true });
       this.waiter = {
         from,
         replyTo,
-        question,
         resolve: (message) => {
-          try {
-            if (!this.saveAnswer(question, message)) {
-              return;
-            }
-            cleanup();
-            resolve(message);
-          } catch (error) {
-            cleanup();
-            reject(asError(error));
-          }
+          cleanup();
+          resolve(message);
         },
         reject: (error) => {
           cleanup();
@@ -213,9 +107,9 @@ export class ReplyWait {
   async transact(activeClient: IntercomTransport, transaction: AskTransaction): Promise<Message> {
     const { to, questionId, options, signal, onSent } = transaction;
     const reply = this.wait({ from: to, replyTo: questionId, signal });
-    // Delivery may reject before the reply is joined; the transaction owns both branches.
+    // A delivery failure may reject before its reply branch is joined.
     reply.catch(() => {
-      /* The original error is propagated below after cleanup. */
+      // The transaction joins this branch after settling delivery.
     });
     try {
       if (signal?.aborted === true) {
@@ -239,7 +133,7 @@ export class ReplyWait {
       try {
         await reply;
       } catch {
-        /* Preserve the delivery failure rather than its cleanup rejection. */
+        // Preserve the delivery failure rather than its cleanup rejection.
       }
       throw error;
     }

package/src/pi-intercom/runtime-types.ts

@@ -1,37 +1,10 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type {
-  Attachment,
-  Message,
-  MessageDelivery,
-  QueueMode,
-  SessionInfo,
-  TopicUpdate,
-} from "./types.ts";
+import type { Attachment, Message, MessageDelivery, QueueMode, SessionInfo } from "./types.ts";
 
-export interface ChildOrchestratorMetadata {
-  readonly orchestratorTarget: string;
-  readonly runId: string;
-  readonly agent: string;
-  readonly index: string;
-  readonly sessionName?: string;
-}
-export interface SubagentCompletion {
-  readonly completionId?: string;
-  readonly runId: string;
-  readonly status: string;
-  readonly children: readonly {
-    readonly agent: string;
-    readonly index: number;
-    readonly status: string;
-    readonly intercomTarget: string;
-  }[];
-}
 export interface InboundMessageEntry {
   readonly from: SessionInfo;
   readonly message: Message;
   readonly replyCommand?: string;
   readonly bodyText: string;
-  readonly subagentCompletion?: SubagentCompletion & { readonly ownerSessionId: string };
 }
 export interface PendingInboundMessage extends InboundMessageEntry {
   readonly flushDelivery: "auto" | "passive" | "steer";
@@ -44,32 +17,15 @@ export type InboundCheckpoint =
       readonly messageId: string;
       readonly stage: PendingInboundMessage["stage"] | "discarded" | "reply-retired";
     };
-export type RequestedDelivery = MessageDelivery | "auto";
 export type InboundDelivery = "trigger" | "followUp" | "steer" | "passive";
-export type ContactSupervisorReason = "need_decision" | "progress_update" | "interview_request";
 export type IntercomSessionScope = "project" | "all";
 export interface ToolResultLike {
   readonly content: readonly { readonly type: "text"; readonly text: string }[];
   readonly isError?: boolean;
   readonly details?: Readonly<Record<string, unknown>>;
 }
-export interface ContactSupervisorToolParams {
-  readonly reason: ContactSupervisorReason;
-  readonly message?: string;
-  readonly interview?: unknown;
-}
 export interface IntercomToolParams {
-  readonly action:
-    | "list"
-    | "send"
-    | "ask"
-    | "reply"
-    | "pending"
-    | "status"
-    | "subscribe"
-    | "unsubscribe"
-    | "publish"
-    | "topics";
+  readonly action: "list" | "send" | "ask" | "reply" | "pending" | "status" | "last";
   readonly scope?: IntercomSessionScope;
   readonly to?: string;
   readonly message?: string;
@@ -79,19 +35,9 @@ export interface IntercomToolParams {
   readonly queueMode?: QueueMode;
   readonly threadId?: string;
   readonly passive?: boolean;
-  readonly topic?: string;
-  readonly event?: TopicUpdate["event"];
-  readonly resource?: string;
-  readonly ownership?: TopicUpdate["ownership"];
-  readonly awaitRelease?: boolean;
-}
-export type ToolRenderTheme = ExtensionContext["ui"]["theme"];
-export interface ToolRenderContext {
-  readonly args?: unknown;
-  readonly isError?: boolean;
-  readonly expanded?: boolean;
+  readonly entryId?: string;
+  readonly offset?: number;
+  readonly limit?: number;
 }
 export const RECIPIENT_TURN_FAILED_ATTACHMENT = "pi-intercom-recipient-turn-failure";
 export const INBOUND_CHECKPOINT_TYPE = "intercom_delivery";
-export const TOPICS_UNAVAILABLE =
-  "Intercom topics are unavailable while an older broker is still running. Direct messaging and active sessions are unchanged. Let its sessions close normally; after it exits, reconnect with the updated package and retry. Nothing was stopped or restarted.";

package/src/pi-intercom/session-events.ts

@@ -3,15 +3,10 @@ import type { IntercomLifecycle } from "./lifecycle.ts";
 import type { IntercomConnection } from "./connection.ts";
 import type { InboundDeliveryOwner } from "./inbound-delivery.ts";
 import type { InboundJournal } from "./inbound-journal.ts";
-import { isDurableSupervisorQuestion, type ReplyTracker } from "./reply-tracker.ts";
+import type { ReplyTracker } from "./reply-tracker.ts";
 import type { ReplyWait } from "./reply-wait.ts";
-import type { IntercomTopics } from "./topics.ts";
-import type { SubagentEventBridges } from "./subagent-events.ts";
-import type { IntercomSupervisor } from "./supervisor.ts";
-import type { PeerAwareness } from "./peer-awareness.ts";
 import { RECIPIENT_TURN_FAILED_ATTACHMENT } from "./runtime-types.ts";
 import { getAssistantErrorMessage, inboundIdFromCustomMessage } from "./message-format.ts";
-import { restoreLazyTools } from "../shared/lazy-tools.ts";
 // The native lifecycle orchestrator explicitly owns these transitions, not other owner operations.
 type Lifecycle = Readonly<
   Pick<
@@ -38,10 +33,7 @@ type Connection = Readonly<
   >
 >;
 type Journal = Readonly<
-  Pick<
-    InboundJournal,
-    "clearNative" | "consume" | "reconcileConsumed" | "reconcileTools" | "reset" | "retire"
-  >
+  Pick<InboundJournal, "clearNative" | "consume" | "reconcileConsumed" | "reset" | "retire">
 >;
 type ReplyWaitHandle = Readonly<Pick<ReplyWait, "reject">>;
 type InboundDeliveryHandle = Readonly<
@@ -50,7 +42,6 @@ type InboundDeliveryHandle = Readonly<
     "clearTimer" | "drain" | "flush" | "redeliver" | "reset" | "schedule" | "start"
   >
 >;
-type TopicOwner = Readonly<Pick<IntercomTopics, "start">>;
 type Replies = Readonly<
   Pick<ReplyTracker, "beginTurn" | "currentTurn" | "endAgent" | "endTurn" | "reset">
 >;
@@ -62,10 +53,6 @@ interface SessionOwners {
   readonly journal: Journal;
   readonly replies: Replies;
   readonly wait: ReplyWaitHandle;
-  readonly topics: TopicOwner;
-  readonly bridges: Readonly<Pick<SubagentEventBridges, "start" | "stop" | "drain">>;
-  readonly supervisor: Readonly<Pick<IntercomSupervisor, "drain">> | null;
-  readonly awareness: Readonly<Pick<PeerAwareness, "reset" | "beforeStart">> | null;
 }
 /** Native phase ordering is centralized here; each resource is cleaned by its owner. */
 export class IntercomSessionEvents {
@@ -76,31 +63,23 @@ export class IntercomSessionEvents {
     this.owners = owners;
   }
   private async start(reason: string, ctx: ExtensionContext): Promise<void> {
-    const { lifecycle, bridges, awareness, connection, topics, delivery } = this.owners;
-    bridges.start();
+    const { lifecycle, connection, delivery } = this.owners;
     const generation = lifecycle.start(ctx);
-    awareness?.reset();
     connection.clearTimers();
-    topics.start(ctx);
-    if (reason !== "reload") {
-      restoreLazyTools(this.pi, ctx, "load_intercom", ["intercom"]);
-    }
     await delivery.start(ctx, reason, generation);
     if (lifecycle.live(ctx, generation)) {
       connection.start(ctx, generation);
     }
   }
   private async shutdown(): Promise<void> {
-    const { bridges, connection, delivery, wait, lifecycle, replies, journal, supervisor } =
-      this.owners;
-    bridges.stop();
+    const { connection, delivery, wait, lifecycle, replies, journal } = this.owners;
     connection.clearTimers();
     delivery.clearTimer();
     wait.reject(new Error("Session shutting down"));
     // Reload keeps the outgoing runner valid until native handoff completes.
     await delivery.drain();
     lifecycle.invalidate();
-    await Promise.allSettled([connection.shutdown(), bridges.drain(), supervisor?.drain()]);
+    await connection.shutdown();
     delivery.reset();
     replies.reset();
     journal.reset();
@@ -133,7 +112,7 @@ export class IntercomSessionEvents {
         replyTo: context.message.id,
         attachments: [{ type: "context", name: RECIPIENT_TURN_FAILED_ATTACHMENT, content: error }],
       });
-      if (result.delivered && !isDurableSupervisorQuestion(context.message)) {
+      if (result.delivered) {
         journal.retire(context.message.id);
       }
     } catch {
@@ -141,7 +120,7 @@ export class IntercomSessionEvents {
     }
   }
   private registerSessionBoundaries(): void {
-    const { lifecycle, connection, journal, awareness } = this.owners;
+    const { lifecycle, connection, journal } = this.owners;
     this.pi.on("session_start", async (event, ctx) => {
       await this.start(event.reason, ctx);
     });
@@ -158,13 +137,6 @@ export class IntercomSessionEvents {
       if (lifecycle.live(ctx)) {
         journal.reconcileConsumed(ctx, true);
       }
-      journal.reconcileTools();
-    });
-    this.pi.on("session_compact", () => {
-      journal.reconcileTools();
-    });
-    this.pi.on("before_agent_start", async (event, ctx) => {
-      await awareness?.beforeStart(event, ctx);
     });
     this.pi.on("model_select", (event, ctx) => {
       if (!lifecycle.live(ctx)) {

package/src/pi-intercom/tool-arguments.ts

@@ -96,6 +96,12 @@ function queueError(params: IntercomToolParams): ToolResultLike | undefined {
   return;
 }
 export function validateIntercomArguments(params: IntercomToolParams): ToolResultLike | undefined {
+  if (
+    (params.entryId !== undefined || params.offset !== undefined || params.limit !== undefined) &&
+    params.action !== "last"
+  ) {
+    return toolError("'entryId', 'offset', and 'limit' are only valid for action='last'");
+  }
   if (params.scope !== undefined && params.action !== "list" && params.action !== "status") {
     return toolError("'scope' is only valid for action='list' or action='status'");
   }

package/src/pi-intercom/tool-registration.ts

@@ -1,121 +1,24 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { IntercomTools } from "./tools.ts";
-import type { IntercomSupervisor } from "./supervisor.ts";
-import type { ToolResultLike } from "./runtime-types.ts";
-import { Type } from "../shared/native-typebox.ts";
-import { activateTools } from "../shared/lazy-tools.ts";
 import { throwIfToolError } from "./tool-results.ts";
-import { intercomSchema, contactSupervisorSchema } from "./tool-schemas.ts";
-import {
-  renderContactCall,
-  renderContactResult,
-  renderIntercomCall,
-  renderIntercomResult,
-} from "./ui/tool-renderers.ts";
-type MessagingTool = Readonly<Pick<IntercomTools, "execute">>;
-type SupervisorTool = Readonly<Pick<IntercomSupervisor, "execute">>;
+import { intercomSchema } from "./tool-schemas.ts";
+import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.ts";
 
-function nativeResult(result: ToolResultLike): {
-  content: { type: "text"; text: string }[];
-  details: Readonly<Record<string, unknown>> | undefined;
-  isError: false;
-} {
-  const success = throwIfToolError(result);
-  return { content: [...success.content], details: success.details, isError: false };
-}
-function registerContact(pi: ExtensionAPI, supervisor: SupervisorTool): void {
-  pi.registerTool({
-    name: "contact_supervisor",
-    label: "Contact Supervisor",
-    description:
-      "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision only when this child cannot safely continue without a decision, approval, or product/API/scope clarification; this steers the supervisor at its next tool boundary and keeps the child alive for the reply. Use interview_request only when multiple structured answers are all required before safe progress; this also steers and waits. Use progress_update only for a discovery or change the supervisor needs while working; it steers at the next tool boundary without waiting for a reply. Skip starts, redundant status, and routine completion; retain material findings in the final result.",
-    promptSnippet:
-      "Subagent-only: steer the supervisor for required decisions, structured interviews, or material discoveries needed during active work. Skip routine status and completion messages.",
-    promptGuidelines: [
-      "Use contact_supervisor with reason='need_decision' when a subagent cannot safely continue without a decision, approval, or product/API/scope clarification; it steers the supervisor and waits for the reply.",
-      "Use contact_supervisor with reason='interview_request' only when the child cannot safely continue until it receives multiple structured answers in one blocking steered exchange.",
-      "Use contact_supervisor with reason='progress_update' only for a discovery or change the supervisor needs while working. It steers at the next tool boundary without waiting. Skip starts, redundant narration, and routine completion; keep material findings in the final result.",
-      "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
-    ],
-    parameters: contactSupervisorSchema,
-    async execute(_id, params, signal, _update, ctx) {
-      return nativeResult(await supervisor.execute(params, signal, ctx));
-    },
-    renderCall: renderContactCall,
-    renderResult: renderContactResult,
-  });
-}
-function registerLoader(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "load_intercom",
-    label: "Load Intercom",
-    description:
-      "Enable local peer coordination: list/check sessions before shared-state work, send or reply to messages, and inspect/publish topics. Does not send a message or check peers itself.",
-    parameters: Type.Object({}),
-    async execute() {
-      if (
-        !pi.getAllTools().some((tool) => tool.name === "intercom" && tool.namespace === undefined)
-      ) {
-        throw new Error("Intercom is excluded from this session.");
-      }
-      activateTools(pi, ["intercom"]);
-      return {
-        content: [
-          {
-            type: "text",
-            text: "Intercom enabled. Use intercom({action:'list'}) to check peers, or status, pending, reply, send, ask and topics for coordination.",
-          },
-        ],
-        details: {},
-      };
-    },
-  });
-}
-function registerMessaging(pi: ExtensionAPI, tools: MessagingTool): void {
+export function registerIntercomTools(
+  pi: ExtensionAPI,
+  tools: Readonly<Pick<IntercomTools, "execute">>,
+): void {
+  registerCompactMessages(pi, ["intercom_message", "subagent-human-message"]);
   pi.registerTool({
     name: "intercom",
-    defaultActive: false,
     label: "Intercom",
-    description: `Send a message to another pi session running on this machine.
-Use this to communicate findings, request help, or coordinate work with other sessions.
-Non-blocking send defaults to steer for guidance, answers, corrections, or blockers that may affect active work. Use queue only when delay is intentional; use ask only when this process must remain alive waiting for the reply.
-
-Usage:
-  intercom({ action: "list" })                    → List sessions in this repository and its worktrees
-  intercom({ action: "list", scope: "all" })      → List connected sessions across every project
-  intercom({ action: "send", to: "session-name", message: "..." })  → Send live coordination (defaults to steer)
-  intercom({ action: "ask", to: "session-name", delivery: "steer", message: "..." })   → Blocking wait only when sender must stay alive
-  intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
-  intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status
-  intercom({ action: "subscribe", topic: "project/work", awaitRelease: true }) → Opt into a topic
-  intercom({ action: "publish", topic: "project/work", message: "Current self-contained state" }) → Quiet latest state
-  intercom({ action: "topics" }) → Inspect topics and current resource owners`,
-    promptSnippet:
-      "Coordinate with local Pi sessions. Non-blocking send defaults to steer for live agent guidance; queue only for intentional delay and ask only for a required blocking reply.",
-    promptGuidelines: [
-      "Intercom list/status defaults to the current Git repository and its worktrees. Use scope='all' only when intentionally discovering sessions in other projects.",
-      "Action='send' defaults to delivery='steer' for agent-to-agent guidance, answers, corrections, blockers, or other context that may affect active work.",
-      "Use delivery='queue' only when delay is intentional. For routine status, explicitly subscribe/publish topics: updates replace quiet inspectable state outside model context, not passive conversation messages. Topic blockers/decisions and awaited ownership releases interrupt; direct messages always bypass subscriptions.",
-      "Treat inbound steered messages as supplemental coordination within the active task: incorporate relevant context and continue; replace the task only when the message explicitly says so.",
-      "Use action='reply' for an active inbound ask. Otherwise respond with send plus steer; use blocking ask only when this process must stay alive and cannot safely continue without the answer.",
-    ],
+    description:
+      "Message connected Pi sessions in your group; mains also reach other mains across projects. List shows target IDs. Ask waits for a correlated reply; reply answers the active or sole pending ask. Pending lists asks; status shows connection and inbound queue. Last pages a peer's last completed response without waking it. Broker acceptance is not recipient persistence, consumption or completion.",
     parameters: intercomSchema,
+    renderResult: renderCompactResult,
     async execute(_id, params, signal, _update, ctx) {
-      return nativeResult(await tools.execute(params, signal, ctx));
+      const result = throwIfToolError(await tools.execute(params, signal, ctx));
+      return { content: [...result.content], details: result.details };
     },
-    renderCall: renderIntercomCall,
-    renderResult: renderIntercomResult,
   });
 }
-export function registerIntercomTools(
-  pi: ExtensionAPI,
-  tools: MessagingTool,
-  supervisor: SupervisorTool | null,
-): void {
-  if (supervisor) {
-    registerContact(pi, supervisor);
-  }
-  registerLoader(pi);
-  registerMessaging(pi, tools);
-}

package/src/pi-intercom/tool-results.ts

@@ -1,5 +1,10 @@
 import type { SendResult } from "./types.ts";
 import type { ToolResultLike } from "./runtime-types.ts";
+type RecoveryCode =
+  | "ambiguous_target"
+  | "reply_timeout"
+  | "no_pending_reply"
+  | "ambiguous_reply_target";
 export interface RecoveryAction {
   readonly action: "list" | "pending" | "send" | "status";
   readonly guidance?: string;
@@ -11,16 +16,12 @@ export function failureDetails(
 ): Readonly<Record<string, unknown>> {
   return { ...details, reasonCode, nextActions };
 }
-export function replyFailureReason(
-  message: string,
-): "no_pending_reply" | "ambiguous_reply_target" | "reply_failed" {
-  if (message.startsWith("No active intercom context") || message.startsWith("No pending ask")) {
-    return "no_pending_reply";
-  }
-  if (message.startsWith("Multiple pending asks") || message.includes("too short")) {
-    return "ambiguous_reply_target";
+export class RecoveryError extends Error {
+  readonly code: RecoveryCode;
+  constructor(code: RecoveryCode, message: string) {
+    super(message);
+    this.code = code;
   }
-  return "reply_failed";
 }
 export function firstTextContent(result: {
   readonly content?: readonly { readonly type: string; readonly text?: string }[];