@fitchmultz/pi-subagents 0.50.0 → 0.51.0

package/dist/pi-intercom/inbound-journal.js

@@ -1,5 +1,8 @@
+import { createHash } from "node:crypto";
+import { isContextRequest } from "./lifecycle.js";
 import { INBOUND_CHECKPOINT_TYPE, } from "./runtime-types.js";
-import { isInboundCheckpoint } from "./inbound-record.js";
+import { isInboundCheckpoint, publicationMetadata, requestedDelivery } from "./inbound-record.js";
+import { isReceiptQuery, } from "./types.js";
 import { inboundIdFromCustomMessage } from "./message-format.js";
 import { isRecord } from "./validation.js";
 export class InboundJournal {
@@ -14,6 +17,72 @@ export class InboundJournal {
         this.pi = pi;
         this.lifecycle = lifecycle;
         this.replies = replies;
+        pi.events.on("pi-intercom:provenance-query", (request) => {
+            if (!isContextRequest(request)) {
+                return;
+            }
+            request.respond(request.version === 1 && isReceiptQuery(request)
+                ? this.receipt(request)
+                : { error: "publication_unavailable" });
+        });
+    }
+    receipt(query) {
+        const ctx = this.lifecycle.live();
+        if (!ctx || ctx.sessionManager.getSessionId() !== query.rootSessionId) {
+            return { error: "publication_unavailable" };
+        }
+        let receipt;
+        for (const item of ctx.sessionManager.getEntries()) {
+            receipt = this.receiptEntry(receipt, query, item);
+        }
+        return receipt ? { receipt } : { error: "receipt_not_found" };
+    }
+    receiptEntry(receipt, query, item) {
+        if (item.type === "custom" &&
+            item.customType === INBOUND_CHECKPOINT_TYPE &&
+            isInboundCheckpoint(item.data) &&
+            item.data.sessionId === query.rootSessionId) {
+            return this.receiptCheckpoint(receipt, query, item.id, item.data);
+        }
+        return receipt && inboundIdFromCustomMessage(item) === query.messageId
+            ? { ...receipt, placementEntryId: item.id }
+            : receipt;
+    }
+    receiptCheckpoint(receipt, query, entryId, data) {
+        if ("entry" in data) {
+            if (receipt || data.entry.message.id !== query.messageId) {
+                return receipt;
+            }
+            const { from, message, stage, receivedAt } = data.entry;
+            return {
+                version: 1,
+                rootSessionId: query.rootSessionId,
+                messageId: query.messageId,
+                sender: {
+                    peerId: from.id,
+                    rootSessionId: from.rootSessionId,
+                    incarnation: from.incarnation,
+                },
+                textSha256: createHash("sha256").update(message.content.text, "utf8").digest("hex"),
+                delivery: requestedDelivery(message),
+                ...publicationMetadata(message),
+                checkpointEntryId: entryId,
+                receivedAt,
+                queued: stage === "queued",
+                nativeHandoff: stage === "native",
+                placementEntryId: null,
+                discarded: false,
+            };
+        }
+        if (!receipt || data.messageId !== query.messageId) {
+            return receipt;
+        }
+        return {
+            ...receipt,
+            queued: receipt.queued || data.stage === "queued",
+            nativeHandoff: receipt.nativeHandoff || data.stage === "native",
+            discarded: receipt.discarded || data.stage === "discarded",
+        };
     }
     peerLeft(id) {
         for (const pending of this.replies.listPending()) {
@@ -24,7 +93,7 @@ export class InboundJournal {
         this.replies.expireSender(id);
         for (const pending of this.queued()) {
             if (pending.from.id === id && pending.message.expectsReply === true) {
-                this.pending.delete(pending.message.id);
+                this.consume(pending.message.id);
                 this.checkpoint({ messageId: pending.message.id, stage: "discarded" });
             }
         }
@@ -42,7 +111,10 @@ export class InboundJournal {
         return this.pending.get(id);
     }
     owns(entry) {
-        return !("stage" in entry) || this.pending.get(entry.message.id) === entry;
+        const id = entry.message.id;
+        return "stage" in entry
+            ? this.pending.get(id) === entry
+            : !this.pending.has(id) && !this.consumed.has(id);
     }
     checkpoint(update) {
         const sessionId = this.lifecycle.currentSessionId;
@@ -77,7 +149,7 @@ export class InboundJournal {
                 if (pending.stage === "queued" &&
                     pending.from.id === entry.from.id &&
                     pending.message.threadId === entry.message.threadId) {
-                    this.pending.delete(pending.message.id);
+                    this.consume(pending.message.id);
                     this.replies.markReplied(pending.message.id);
                 }
             }
@@ -135,7 +207,7 @@ export class InboundJournal {
             return;
         }
         if (data.stage === "discarded") {
-            this.pending.delete(data.messageId);
+            this.consume(data.messageId);
             this.replies.markReplied(data.messageId);
             return;
         }
@@ -163,6 +235,11 @@ export class InboundJournal {
         if (item.customType === "intercom_sent") {
             this.restoreSent(item.data);
         }
+        if (item.customType === "intercom_received" &&
+            isRecord(item.data) &&
+            typeof item.data.messageId === "string") {
+            this.consume(item.data.messageId);
+        }
     }
     restoreSent(data) {
         if (isRecord(data) &&
@@ -194,7 +271,7 @@ export class InboundJournal {
         return ((entry.type === "custom_message" &&
             ["intercom_message", "subagent-human-message"].includes(entry.customType)) ||
             (entry.type === "custom" &&
-                [INBOUND_CHECKPOINT_TYPE, "intercom_sent"].includes(entry.customType)));
+                [INBOUND_CHECKPOINT_TYPE, "intercom_sent", "intercom_received"].includes(entry.customType)));
     }
     recentEntries(ctx, fullScan) {
         if (fullScan) {

package/dist/pi-intercom/inbound-record.js

@@ -1,10 +1,25 @@
 import { isMessage, isSessionRegistration } from "./types.js";
 import { finiteNumber, isRecord } from "./validation.js";
+export function publicationMetadata(message) {
+    return {
+        guard: message.guard && {
+            rootSessionId: message.guard.rootSessionId,
+            peerId: message.guard.peerId,
+            incarnation: message.guard.incarnation,
+            applicationGuard: message.guard.applicationGuard,
+        },
+        replyHint: message.replyHint && {
+            tool: message.replyHint.tool,
+            commandId: message.replyHint.commandId,
+            commandFingerprint: message.replyHint.commandFingerprint,
+        },
+    };
+}
 export function requestedDelivery(message) {
     if (message.passive === true || message.delivery === "passive") {
         return "passive";
     }
-    return message.delivery ?? (message.expectsReply === true ? "auto" : "steer");
+    return message.delivery ?? "steer";
 }
 function isLocalJournalMessage(value) {
     if (!isRecord(value) || !isRecord(value.content)) {
@@ -25,6 +40,8 @@ function isLocalJournalMessage(value) {
             "queueMode",
             "threadId",
             "passive",
+            "guard",
+            "replyHint",
         ].every((key) => value[key] === undefined));
 }
 function isJournalMessage(value, sender) {

package/dist/pi-intercom/inbound.js

@@ -45,63 +45,30 @@ export class IntercomInbound {
         }
         return true;
     }
-    async busyNonInteractive(entry, ctx, generation) {
-        if (entry.message.expectsReply !== true) {
-            this.owners.delivery.send(entry, "steer", generation);
-            return;
-        }
-        const active = this.owners.connection.active;
-        if (entry.message.replyTo !== undefined || active?.isConnected() !== true) {
-            return;
-        }
-        try {
-            const result = await active.send(entry.from.id, {
-                text: "This agent is running in non-interactive mode and cannot respond to intercom messages while it is working. It will continue its current task and exit when done.",
-                replyTo: entry.message.id,
-            });
-            if (result.delivered && this.lifecycle.live(ctx, generation)) {
-                this.owners.replies.markReplied(entry.message.id);
-                this.lifecycle.markActivity();
-                this.owners.connection.syncStatus();
-            }
-        }
-        catch {
-            /* Best-effort busy reply; the non-interactive task must continue either way. */
-        }
-    }
     async admit(entry, live, generation) {
         const active = this.lifecycle.live(live, generation);
         if (!active || this.queueAdmission(entry, active)) {
             return;
         }
         if (!this.lifecycle.isIdle(active)) {
-            await this.busy(entry, active, generation);
+            this.busy(entry, generation);
             return;
         }
         if (this.lifecycle.live(live, generation)) {
             this.owners.delivery.send(entry, requestedDelivery(entry.message) === "passive" ? "passive" : "trigger", generation);
         }
     }
-    async busy(entry, ctx, generation) {
+    busy(entry, generation) {
         const delivery = requestedDelivery(entry.message);
         if (delivery === "steer") {
             this.owners.delivery.send(entry, "steer", generation);
-            await this.owners.delivery.detach(entry, entry.message.expectsReply !== true);
             return;
         }
-        if (delivery === "queue" && entry.message.queueMode !== "replace") {
+        if (delivery === "queue") {
             this.owners.delivery.send(entry, "followUp", generation);
             return;
         }
-        if (delivery === "passive") {
-            this.owners.delivery.queue(entry, "passive");
-            return;
-        }
-        if (!ctx.hasUI) {
-            await this.busyNonInteractive(entry, ctx, generation);
-            return;
-        }
-        this.owners.delivery.queue(entry, "auto");
+        this.owners.delivery.queue(entry, "passive");
     }
     async receive(ctx, from, input) {
         const generation = this.lifecycle.generation;
@@ -113,9 +80,17 @@ export class IntercomInbound {
         if (!live) {
             return;
         }
+        if (input.guard && !this.lifecycle.accepts(input.guard)) {
+            return;
+        }
         // Peer metadata never grants user authority.
         const message = input.human ? { ...input, human: undefined } : input;
+        const entry = this.entry(from, message);
+        if (!this.owners.journal.owns(entry)) {
+            return;
+        }
         if (this.owners.wait.receive(from, message, () => {
+            this.owners.journal.consume(message.id);
             this.lifecycle.markActivity();
             this.owners.connection.syncStatus();
         })) {
@@ -124,7 +99,6 @@ export class IntercomInbound {
         this.owners.replies.recordIncomingMessage(from, message);
         this.lifecycle.markActivity();
         this.owners.connection.syncStatus();
-        const entry = this.entry(from, message);
         await this.admit(entry, live, generation);
     }
 }

package/dist/pi-intercom/index.js

@@ -21,6 +21,7 @@ export default function piIntercomExtension(pi) {
     const connection = new IntercomConnection(lifecycle, config, {
         restoring: () => delivery.restoring,
         pendingAsks: () => replies.listPending().length,
+        receipt: (query) => journal.receipt(query),
         incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
         peerLeft: (id) => {
             wait.peerDisconnected(id);
@@ -34,8 +35,10 @@ export default function piIntercomExtension(pi) {
         replies,
         syncStatus: () => connection.syncStatus(),
     });
+    lifecycle.registerContextEvents(() => connection.syncStatus());
     const inbound = new IntercomInbound(lifecycle, config, {
         delivery,
+        journal,
         replies,
         wait,
         connection,

package/dist/pi-intercom/last-message.js

@@ -1,17 +1,6 @@
-function validPage(offset, limit) {
-    return (Number.isSafeInteger(offset) &&
-        offset >= 0 &&
-        Number.isSafeInteger(limit) &&
-        limit >= 1 &&
-        limit <= 16384);
-}
+import { isLastMessageQuery, LAST_MESSAGE_PAGE_LIMIT, } from "./types.js";
 function completedResponse(manager, entryId) {
-    let id = manager.getLeafId();
-    while (id !== null) {
-        const entry = manager.getEntry(id);
-        if (!entry) {
-            throw new Error("Native session history is unavailable.");
-        }
+    for (const entry of manager.getBranch().reverse()) {
         if (entry.type === "message" &&
             entry.message.role === "assistant" &&
             (entry.message.stopReason === "stop" || entry.message.stopReason === "length") &&
@@ -24,15 +13,14 @@ function completedResponse(manager, entryId) {
                     .join("\n"),
             };
         }
-        id = entry.parentId;
     }
     return;
 }
 /** Reads finalized native history only; no model invocation or synthesized response. */
 export function readLastMessage(manager, session, query) {
     const offset = query.offset ?? 0;
-    const limit = query.limit ?? 16384;
-    if (!validPage(offset, limit)) {
+    const limit = query.limit ?? LAST_MESSAGE_PAGE_LIMIT;
+    if (!isLastMessageQuery({ offset, limit })) {
         return {
             error: "Invalid last response page: offset must be non-negative and limit must be 1–16384.",
         };

package/dist/pi-intercom/lifecycle.js

@@ -1,5 +1,11 @@
+import { randomUUID } from "node:crypto";
 import { buildPresenceIdentity } from "./identity.js";
 import { resolveSessionProjectId } from "./session-targets.js";
+import { isContextTarget, } from "./types.js";
+import { isRecord, safeLabel } from "./validation.js";
+export function isContextRequest(value) {
+    return isRecord(value) && typeof value.respond === "function";
+}
 /** Owns native context validity and occupancy, never journal or socket state. */
 export class IntercomLifecycle {
     context = null;
@@ -7,6 +13,10 @@ export class IntercomLifecycle {
     model = "unknown";
     disposed = true;
     epoch = 0;
+    incarnation = null;
+    peerId = null;
+    guardedDelivery = false;
+    applicationGuard;
     running = false;
     activity = 0;
     tools = new Map();
@@ -27,15 +37,87 @@ export class IntercomLifecycle {
     get toolCount() {
         return this.tools.size;
     }
+    registerContextEvents(sync) {
+        this.pi.events.on("pi-intercom:context-query", (request) => this.contextRequest(request));
+        this.pi.events.on("pi-intercom:application-guard", (request) => this.contextRequest(request, sync));
+    }
+    contextRequest(request, sync) {
+        if (!isContextRequest(request)) {
+            return;
+        }
+        if (request.version !== 1) {
+            request.respond({ error: "unsupported_version" });
+            return;
+        }
+        if (sync) {
+            if (!isContextTarget(request.target) ||
+                !this.matches(request.target) ||
+                !(request.revision === null ||
+                    (typeof request.revision === "string" && safeLabel(request.revision)))) {
+                request.respond({ error: "context_changed" });
+                return;
+            }
+            this.applicationGuard = request.revision === null ? undefined : request.revision;
+            sync();
+            this.publishContext();
+        }
+        request.respond(this.snapshot());
+    }
+    snapshot() {
+        if (!this.live()) {
+            return {
+                version: 1,
+                rootSessionId: null,
+                peerId: null,
+                incarnation: null,
+                connected: false,
+                guardedDelivery: null,
+            };
+        }
+        return {
+            version: 1,
+            rootSessionId: this.lineage?.rootSessionId ?? this.sessionId,
+            parentSessionId: this.lineage?.parentSessionId,
+            peerId: this.peerId,
+            incarnation: this.incarnation,
+            connected: this.peerId !== null,
+            guardedDelivery: this.guardedDelivery ? 1 : null,
+            applicationGuard: this.applicationGuard,
+        };
+    }
+    publishContext() {
+        this.pi.events.emit("pi-intercom:context-state", this.snapshot());
+    }
+    transport(peerId, guardedDelivery = false) {
+        this.peerId = peerId;
+        this.guardedDelivery = guardedDelivery;
+        this.publishContext();
+    }
+    matches(target) {
+        const current = this.snapshot();
+        return (current.connected &&
+            current.rootSessionId === target.rootSessionId &&
+            current.peerId === target.peerId &&
+            current.incarnation === target.incarnation);
+    }
+    accepts(guard) {
+        return (this.guardedDelivery &&
+            this.lineage?.parentSessionId === undefined &&
+            this.matches(guard) &&
+            this.applicationGuard === guard.applicationGuard);
+    }
     start(ctx) {
         this.disposed = false;
         this.epoch += 1;
         this.context = ctx;
         this.sessionId = ctx.sessionManager.getSessionId();
+        this.incarnation = randomUUID();
+        this.applicationGuard = undefined;
         this.model = ctx.model?.id ?? "unknown";
         this.running = false;
         this.activity = 0;
         this.tools.clear();
+        this.transport(null);
         return this.epoch;
     }
     invalidate() {
@@ -43,6 +125,7 @@ export class IntercomLifecycle {
         this.epoch += 1;
         this.running = false;
         this.tools.clear();
+        this.publishContext();
     }
     clear() {
         this.context = null;
@@ -129,12 +212,14 @@ export class IntercomLifecycle {
         if (!live || this.sessionId === null) {
             throw new Error("Intercom runtime not initialized");
         }
-        const cwd = live.cwd;
         return {
             ...this.identity(this.sessionId),
-            cwd,
+            incarnation: this.incarnation ?? undefined,
+            guardedDelivery: 1,
+            applicationGuard: this.applicationGuard,
+            cwd: live.cwd,
             model: this.model,
-            projectId: await resolveSessionProjectId(cwd),
+            projectId: await resolveSessionProjectId(live.cwd),
             lastSeen: Date.now(),
             status: this.status(),
             ...this.health(pendingAsks),

package/dist/pi-intercom/outbound.js

@@ -3,7 +3,7 @@ import { resolveConnectedTarget, resolvePeerHealth, } from "./connection.js";
 import { RECIPIENT_TURN_FAILED_ATTACHMENT, } from "./runtime-types.js";
 import { errorMessage } from "./validation.js";
 import { formatAttachments } from "./message-format.js";
-import { AskDeliveryError, failureDetails, replyFailureReason, } from "./tool-results.js";
+import { AskDeliveryError, failureDetails, RecoveryError, } from "./tool-results.js";
 import { sendOptions, toolError, toolText } from "./tool-arguments.js";
 export class IntercomOutbound {
     owners;
@@ -101,8 +101,7 @@ export class IntercomOutbound {
             return this.sent(to, params, result);
         }
         catch (error) {
-            const text = errorMessage(error);
-            return toolError(`Failed to send: ${text}`, failureDetails(text.startsWith("Target ") ? "ambiguous_target" : "send_failed", [
+            return toolError(`Failed to send: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "send_failed", [
                 { action: "list" },
                 { action: "send", guidance: "Retry with an exact active recipient target." },
             ], { error: true }));
@@ -147,15 +146,7 @@ export class IntercomOutbound {
             const result = this.deliveryFailure(to, error.result);
             return { ...result, details: { ...result.details, error: true } };
         }
-        const text = errorMessage(error);
-        let reason = "ask_failed";
-        if (text.startsWith("No reply from")) {
-            reason = "reply_timeout";
-        }
-        else if (text.startsWith("Target ")) {
-            reason = "ambiguous_target";
-        }
-        return toolError(`Failed: ${text}`, failureDetails(reason, [
+        return toolError(`Failed: ${errorMessage(error)}`, failureDetails(error instanceof RecoveryError ? error.code : "ask_failed", [
             { action: "status" },
             { action: "list" },
             {
@@ -293,8 +284,7 @@ export class IntercomOutbound {
         }
     }
     replyFailure(error, replyTo) {
-        const text = errorMessage(error);
-        const reason = replyFailureReason(text);
+        const reason = error instanceof RecoveryError ? error.code : "reply_failed";
         const actions = reason === "no_pending_reply"
             ? [
                 { action: "pending" },
@@ -304,7 +294,7 @@ export class IntercomOutbound {
                 },
             ]
             : [{ action: "pending" }, { action: "list" }];
-        return toolError(`Failed to reply: ${text}`, failureDetails(reason, actions, {
+        return toolError(`Failed to reply: ${errorMessage(error)}`, failureDetails(reason, actions, {
             error: true,
             ...((replyTo ?? "") !== "" ? { replyTo } : {}),
         }));

package/dist/pi-intercom/reply-tracker.js

@@ -1,4 +1,5 @@
 import { formatSessionTarget, resolveSessionTarget, shortSessionId } from "./session-targets.js";
+import { RecoveryError } from "./tool-results.js";
 function resolveBySenderTarget(contexts, to) {
     const sessions = contexts.map((context) => context.from);
     const resolution = resolveSessionTarget(sessions, to);
@@ -26,14 +27,14 @@ function pendingSenderOptions(contexts, allContexts = contexts) {
 function matchingSender(contexts, to) {
     const tooShort = tooShortSenderTargetMessage(contexts, to);
     if (tooShort !== null && tooShort !== "") {
-        throw new Error(tooShort);
+        throw new RecoveryError("ambiguous_reply_target", tooShort);
     }
     return resolveBySenderTarget(contexts, to);
 }
 function explicitReply(contexts, replyTo, to) {
     const target = contexts.find((context) => context.message.id === replyTo);
     if (!target) {
-        throw new Error(`No pending ask with replyTo "${replyTo}"`);
+        throw new RecoveryError("no_pending_reply", `No pending ask with replyTo "${replyTo}"`);
     }
     if (to !== "" &&
         !matchingSender(contexts, to).some((context) => context.message.id === target.message.id)) {
@@ -47,9 +48,9 @@ function replyBySender(contexts, to) {
         return matches[0];
     }
     if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
+        throw new RecoveryError("ambiguous_reply_target", `Multiple pending asks from "${to}" — use one of: ${pendingSenderOptions(matches, contexts)}.`);
     }
-    throw new Error(`No pending ask from "${to}"`);
+    throw new RecoveryError("no_pending_reply", `No pending ask from "${to}"`);
 }
 export class ReplyTracker {
     pendingAsks = new Map();
@@ -151,9 +152,9 @@ export class ReplyTracker {
             return pending[0];
         }
         if (pending.length === 0) {
-            throw new Error("No active intercom context to reply to");
+            throw new RecoveryError("no_pending_reply", "No active intercom context to reply to");
         }
-        throw new Error("Multiple pending asks — specify `to`");
+        throw new RecoveryError("ambiguous_reply_target", "Multiple pending asks — specify `to`");
     }
     markReplied(replyTo) {
         this.removeContext(replyTo);

package/dist/pi-intercom/reply-wait.js

@@ -1,5 +1,5 @@
 import { asError } from "./validation.js";
-import { AskDeliveryError } from "./tool-results.js";
+import { AskDeliveryError, RecoveryError } from "./tool-results.js";
 /** One correlated blocking wait; admitted before send so a fast reply cannot race it. */
 export class ReplyWait {
     waiter = null;
@@ -42,7 +42,7 @@ export class ReplyWait {
         return new Promise((resolve, reject) => {
             const { from, replyTo, signal } = options;
             const timeout = setTimeout(() => {
-                this.reject(new Error(`No reply from "${from}" within ${Math.max(1, Math.round(this.timeoutMs / 60000))} minute(s)`));
+                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 = () => {

package/dist/pi-intercom/session-targets.d.ts

@@ -0,0 +1,24 @@
+export interface TargetIdentity {
+    readonly id: string;
+    readonly name?: string;
+}
+export interface ProjectSessionIdentity extends TargetIdentity {
+    readonly cwd: string;
+    readonly projectId?: string;
+}
+export declare const MIN_SESSION_TARGET_PREFIX_LENGTH = 8;
+export declare function nativePeerId(sessionId: string): string;
+export interface TargetResolution<T extends TargetIdentity> {
+    readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
+    readonly target?: T;
+    readonly matches: readonly T[];
+}
+export declare function shortSessionId(sessionId: string): string;
+export declare function resolveSessionProjectId(cwd: string): Promise<string>;
+export declare function formatSessionTarget(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare function formatTargetOptions(sessions: readonly TargetIdentity[], allSessions?: readonly TargetIdentity[]): string;
+export declare function targetDisplayName(session: TargetIdentity, allSessions?: readonly TargetIdentity[]): string;
+export declare const PEER_AWARENESS_HINT = "Other Pi sessions may be connected to this project. Use load_intercom({}) if needed, then intercom({ action: \"list\" }) before changing shared state or coordinating known overlapping work. Routine standalone read-only tasks do not need a peer check. Coordinate only when work overlaps; use subagent controls for managed child runs.";
+export declare function filterProjectSessions<T extends ProjectSessionIdentity>(sessions: readonly T[], currentSessionId: string): T[];
+export declare function formatPeerAwarenessHint(sessions: readonly ProjectSessionIdentity[], currentSessionId: string): string | undefined;
+export declare function resolveSessionTarget<T extends TargetIdentity>(sessions: readonly T[], rawTarget: string): TargetResolution<T>;

package/dist/pi-intercom/tool-registration.js

@@ -1,11 +1,14 @@
 import { throwIfToolError } from "./tool-results.js";
 import { intercomSchema } from "./tool-schemas.js";
+import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.js";
 export function registerIntercomTools(pi, tools) {
+    registerCompactMessages(pi, ["intercom_message", "subagent-human-message"]);
     pi.registerTool({
         name: "intercom",
         label: "Intercom",
-        description: "Discover and message connected Pi sessions in your collaboration group; main sessions can also reach other mains, across projects. Use list for unambiguous targets. Send defaults to steer at the next tool boundary; queue defers; passive never wakes the model. Ask waits for a correlated reply; reply answers the active or single pending ask (specify replyTo when ambiguous). Pending lists asks; status shows connection and inbound queue state. Last reads a peer's original completed assistant response without waking it; page using entryId and nextOffset. Broker acceptance is not recipient persistence, consumption, or task completion.",
+        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) {
             const result = throwIfToolError(await tools.execute(params, signal, ctx));
             return { content: [...result.content], details: result.details };

package/dist/pi-intercom/tool-results.js

@@ -1,14 +1,12 @@
 export function failureDetails(reasonCode, nextActions, details = {}) {
     return { ...details, reasonCode, nextActions };
 }
-export function replyFailureReason(message) {
-    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 {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
     }
-    return "reply_failed";
 }
 export function firstTextContent(result) {
     return (result.content