@fitchmultz/pi-subagents 0.50.0 → 0.51.0

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

@@ -1,24 +1,42 @@
 import { randomUUID } from "node:crypto";
 import { isRecord } from "../../shared/unknown.js";
-import { normalizeSessionInfo, } from "../types.js";
+import { isDeliveryGuard, isPublicationReplyHint, isLastMessageQuery, isReceiptQuery, LAST_MESSAGE_PAGE_LIMIT, normalizeSessionInfo, } from "../types.js";
+import { finiteNumber, nonNegativeInteger, optionalLabel, safeLabel } from "../validation.js";
 import { validateIntercomMessageSize, writeMessage } from "./framing.js";
 import { messageSender } from "./snapshots.js";
 import { findSessions } from "./targets.js";
-export const LAST_MESSAGE_PAGE_LIMIT = 16384;
-function nonNegativeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+export function isNativeReadQuery(value) {
+    return isReceiptQuery(value) || isLastMessageQuery(value);
 }
-function optionalEntryId(value) {
-    return value === undefined || (typeof value === "string" && value.length > 0);
+function isNativeReceipt(value) {
+    if (!isReceiptQuery(value) || !isRecord(value) || !isRecord(value.sender)) {
+        return false;
+    }
+    return (value.version === 1 &&
+        safeLabel(value.sender.peerId) &&
+        [value.sender.rootSessionId, value.sender.incarnation].every(optionalLabel) &&
+        typeof value.textSha256 === "string" &&
+        /^[a-f0-9]{64}$/.test(value.textSha256) &&
+        receiptPublication(value) &&
+        receiptFacts(value));
 }
-export function isLastMessageQuery(value) {
-    return (isRecord(value) &&
-        optionalEntryId(value.entryId) &&
-        (value.offset === undefined || nonNegativeInteger(value.offset)) &&
-        (value.limit === undefined ||
-            (nonNegativeInteger(value.limit) &&
-                value.limit > 0 &&
-                value.limit <= LAST_MESSAGE_PAGE_LIMIT)));
+function receiptPublication(value) {
+    return (typeof value.delivery === "string" &&
+        ["queue", "steer", "passive"].includes(value.delivery) &&
+        (value.guard === undefined || isDeliveryGuard(value.guard)) &&
+        (value.replyHint === undefined || isPublicationReplyHint(value.replyHint)));
+}
+function receiptFacts(value) {
+    return (safeLabel(value.checkpointEntryId) &&
+        finiteNumber(value.receivedAt) &&
+        [value.queued, value.nativeHandoff, value.discarded].every((field) => typeof field === "boolean") &&
+        (value.placementEntryId === null || safeLabel(value.placementEntryId)));
+}
+export function isReceiptResult(value) {
+    return isRecord(value) && (typeof value.error === "string" || isNativeReceipt(value.receipt));
+}
+export function isNativeReadResult(value) {
+    return isReceiptResult(value) || isLastMessageResult(value);
 }
 function pageIdentity(value) {
     return (normalizeSessionInfo(value.session) !== null &&
@@ -45,7 +63,7 @@ export function isLastMessageResult(value) {
     return (isRecord(value) &&
         (typeof value.error === "string" || (pageIdentity(value) && pageOffsets(value))));
 }
-function unavailable(targets, name, pending) {
+function unavailable(targets, name, pending, query) {
     if (targets.length === 0) {
         return "Session not found";
     }
@@ -55,6 +73,10 @@ function unavailable(targets, name, pending) {
     if (!targets[0].lastMessages) {
         return "Recipient does not support last-message reads; reload its extension.";
     }
+    if ("messageId" in query &&
+        (!targets[0].receiptReads || targets[0].info.rootSessionId !== query.rootSessionId)) {
+        return "publication_unavailable";
+    }
     if (pending >= 128) {
         return "Too many pending last-message reads; retry after they settle.";
     }
@@ -64,10 +86,21 @@ function matchesPage(result, pending, fromId) {
     if ("error" in result) {
         return true;
     }
+    if ("messageId" in pending.query) {
+        return ("receipt" in result &&
+            result.receipt.messageId === pending.query.messageId &&
+            result.receipt.rootSessionId === pending.query.rootSessionId);
+    }
+    if ("receipt" in result) {
+        return false;
+    }
+    return matchesLastPage(result, pending.query, fromId);
+}
+function matchesLastPage(result, query, fromId) {
     return (result.session.id === fromId &&
-        result.offset === (pending.query.offset ?? 0) &&
-        (pending.query.entryId === undefined || result.entryId === pending.query.entryId) &&
-        result.text.length <= (pending.query.limit ?? LAST_MESSAGE_PAGE_LIMIT));
+        result.offset === (query.offset ?? 0) &&
+        (query.entryId === undefined || result.entryId === query.entryId) &&
+        result.text.length <= (query.limit ?? LAST_MESSAGE_PAGE_LIMIT));
 }
 /** Correlation belongs to the broker, not the requester or the recipient's model queue. */
 export class LastMessageRelay {
@@ -79,7 +112,7 @@ export class LastMessageRelay {
     request(fromId, message) {
         if (typeof message.requestId !== "string" ||
             typeof message.to !== "string" ||
-            !isLastMessageQuery(message.query)) {
+            !isNativeReadQuery(message.query)) {
             throw new Error("Invalid last message request");
         }
         const targets = findSessions(this.sessions, message.to, fromId);
@@ -88,15 +121,6 @@ export class LastMessageRelay {
         if (!from) {
             return;
         }
-        const error = unavailable(targets, message.to, this.pending.size);
-        if (error !== undefined) {
-            writeMessage(from.socket, {
-                type: "last_response",
-                requestId: message.requestId,
-                result: { error },
-            });
-            return;
-        }
         const token = randomUUID();
         const frame = {
             type: "last_request",
@@ -104,12 +128,13 @@ export class LastMessageRelay {
             from: messageSender(from.info),
             query: message.query,
         };
-        const invalid = validateIntercomMessageSize(frame);
-        if (invalid) {
+        const error = unavailable(targets, message.to, this.pending.size, message.query) ??
+            validateIntercomMessageSize(frame)?.message;
+        if (error !== undefined) {
             writeMessage(from.socket, {
                 type: "last_response",
                 requestId: message.requestId,
-                result: { error: invalid.message },
+                result: { error },
             });
             return;
         }
@@ -138,7 +163,7 @@ export class LastMessageRelay {
             return;
         }
         const result = message.result;
-        this.finish(message.requestId, isLastMessageResult(result) && matchesPage(result, pending, fromId)
+        this.finish(message.requestId, isNativeReadResult(result) && matchesPage(result, pending, fromId)
             ? result
             : { error: "Recipient returned an invalid last-message page" });
     }

package/dist/pi-intercom/broker/paths.d.ts

@@ -0,0 +1,13 @@
+/** Old agent-directory namespaces are inspected for migration, never used for routing. */
+export declare function getPreviousBrokerSocketPaths(): readonly string[];
+export declare function isOwnedBrokerSocket(socketPath: string): boolean;
+/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
+export declare function getBrokerRuntimeDir(): string;
+/** Read-only child observation endpoints share the runtime policy, not the broker namespace.
+ * The endpoint name is a short token digest because the private runtime directory also counts
+ * toward the Unix-socket path limit; a full token made nested test/deployment roots overflow. */
+export declare function agentObservationSocketPath(token: string): string;
+export declare function getBrokerSocketPath(): string;
+/** Create or verify an owned, non-symlink, private socket directory. */
+export declare function preparePrivateSocketPath(socketPath: string): string;
+export declare function prepareBrokerSocketPath(): string;

package/dist/pi-intercom/broker/paths.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { getPiAgentDir } from "../agent-dir.js";
 const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 function agentDigest(agentDir, uid) {
@@ -32,33 +32,56 @@ export function isOwnedBrokerSocket(socketPath) {
         return false;
     }
 }
-/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
-export function getBrokerRuntimeDir() {
+function defaultRuntimeRoot() {
+    if (process.platform !== "android") {
+        return "/tmp";
+    }
+    return process.env.PREFIX === undefined ? tmpdir() : join(process.env.PREFIX, "tmp");
+}
+function runtimeDirectory(socketName, sibling = "") {
     const configured = process.env.PI_INTERCOM_RUNTIME_DIR;
     const uid = process.getuid?.();
     if (uid === undefined) {
         throw new Error("Intercom requires Unix user IDs and Unix domain sockets.");
     }
-    const directory = configured ?? join("/tmp", `pi-intercom-${uid}`);
+    const base = configured ?? join(defaultRuntimeRoot(), `pi-intercom-${uid}`);
+    const directory = isAbsolute(base) && sibling !== "" ? `${resolve(base)}${sibling}` : base;
     if (!isAbsolute(directory) ||
         directory.includes("\0") ||
-        Buffer.byteLength(join(directory, "broker.sock")) > MAX_UNIX_SOCKET_PATH_BYTES) {
+        Buffer.byteLength(join(directory, socketName)) > MAX_UNIX_SOCKET_PATH_BYTES) {
         throw new Error("PI_INTERCOM_RUNTIME_DIR must be an absolute short Unix socket directory.");
     }
     return directory;
 }
+/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
+export function getBrokerRuntimeDir() {
+    return runtimeDirectory("broker.sock");
+}
+/** Read-only child observation endpoints share the runtime policy, not the broker namespace.
+ * The endpoint name is a short token digest because the private runtime directory also counts
+ * toward the Unix-socket path limit; a full token made nested test/deployment roots overflow. */
+export function agentObservationSocketPath(token) {
+    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(token)) {
+        throw new Error("Invalid actor token.");
+    }
+    const name = `obs-${createHash("sha256").update(token).digest("hex").slice(0, 16)}.sock`;
+    return join(runtimeDirectory(name, "-agents"), name);
+}
 export function getBrokerSocketPath() {
     return join(getBrokerRuntimeDir(), "broker.sock");
 }
-export function prepareBrokerSocketPath() {
-    const socketPath = getBrokerSocketPath();
-    const brokerDir = dirname(socketPath);
-    fs.mkdirSync(brokerDir, { recursive: true, mode: 0o700 });
-    const stat = fs.lstatSync(brokerDir);
+/** Create or verify an owned, non-symlink, private socket directory. */
+export function preparePrivateSocketPath(socketPath) {
+    const directory = dirname(socketPath);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(directory);
     const uid = process.getuid?.();
     if (!stat.isDirectory() || stat.isSymbolicLink() || (uid !== undefined && stat.uid !== uid)) {
-        throw new Error(`Unsafe intercom socket directory: ${brokerDir}`);
+        throw new Error(`Unsafe intercom socket directory: ${directory}`);
     }
-    fs.chmodSync(brokerDir, 0o700);
+    fs.chmodSync(directory, 0o700);
     return socketPath;
 }
+export function prepareBrokerSocketPath() {
+    return preparePrivateSocketPath(getBrokerSocketPath());
+}

package/dist/pi-intercom/broker/pid.js

@@ -73,6 +73,10 @@ export function brokerPidRecord() {
     return `${process.pid}\n${identity !== undefined ? `${identity}\n` : ""}`;
 }
 export function isBrokerPidReused(pid, record) {
+    return isLinuxProcessReplaced(pid, record.slice(record.indexOf("\n") + 1));
+}
+/** True only when a live Linux PID provably names a different process than the identity. */
+export function isLinuxProcessReplaced(pid, identity) {
     const current = readLinuxProcess(pid);
     if (!current) {
         return false;
@@ -80,7 +84,7 @@ export function isBrokerPidReused(pid, record) {
     if (current.tgid !== pid) {
         return true;
     }
-    const saved = IDENTITY.exec(record.slice(record.indexOf("\n") + 1).trim());
+    const saved = IDENTITY.exec(identity.trim());
     const actual = IDENTITY.exec(current.identity ?? "");
     if (!saved || !actual) {
         return false;

package/dist/pi-intercom/broker/server-connection.js

@@ -1,4 +1,23 @@
+import { randomUUID } from "node:crypto";
 import { createMessageReader } from "./framing.js";
+import { assertMainParent } from "./targets.js";
+import { isSessionRegistration } from "../types.js";
+export function registeredSessionInfo(msg, sessions) {
+    if (!isSessionRegistration(msg.session)) {
+        throw new Error("Invalid register message");
+    }
+    assertMainParent(msg.session, sessions);
+    const requestedId = typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
+        ? msg.requestedId
+        : undefined;
+    const id = requestedId !== undefined && !sessions.has(requestedId) ? requestedId : randomUUID();
+    return {
+        ...msg.session,
+        id,
+        guardedDelivery: msg.guardedDelivery === 1 ? msg.session.guardedDelivery : undefined,
+        lastSeen: msg.session.lastSeen ?? Date.now(),
+    };
+}
 /** A server connection owns its registration identity until the socket closes. */
 export function acceptBrokerConnection(socket, handleMessage, disconnected) {
     let sessionId = null;

package/dist/pi-intercom/broker/snapshot-reader.d.ts

@@ -0,0 +1,9 @@
+import { type SessionSnapshot } from "../types.ts";
+/** Multipart frames build a private cache; only a complete validated snapshot escapes. */
+export declare class SnapshotReader {
+    private readonly sessions;
+    private readonly receipts;
+    private addSession;
+    append(sessions: readonly unknown[], receipts: unknown): void;
+    finish(): SessionSnapshot;
+}

package/dist/pi-intercom/broker/snapshots.d.ts

@@ -0,0 +1,29 @@
+import { type SessionInfo, type TopicUpdate, type Message, type BrokerMessage, type TopicSubscription, type SendResult } from "../types.ts";
+/** Direct messages and old clients receive identity, not potentially large topic state. */
+export declare function messageSender(info: SessionInfo): SessionInfo;
+export declare function snapshotFrames(requestId: string, infos: readonly SessionInfo[], stream: boolean): BrokerMessage[];
+interface PreparedTopicChange {
+    readonly topic?: TopicUpdate;
+    readonly subscription?: TopicSubscription;
+    readonly unsubscribe?: string;
+    readonly publication?: TopicUpdate;
+    readonly restore: boolean;
+    readonly changed: boolean;
+    readonly bytes: number;
+}
+/** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
+export declare class TopicSnapshot {
+    private readonly topics;
+    private readonly subscriptions;
+    constructor(info: SessionInfo);
+    subscription(topic: string): TopicSubscription | undefined;
+    prepare(change: unknown, supported: boolean): PreparedTopicChange;
+    private preparePublication;
+    snapshot(info: SessionInfo, prepared?: PreparedTopicChange): SessionInfo;
+    validateRestore(info: SessionInfo, prepared: PreparedTopicChange, requestId: string): void;
+    commit(prepared: PreparedTopicChange): void;
+}
+export declare function deliveryAcknowledgement(receipt: SendResult): BrokerMessage;
+export declare function shouldReplaceDelivery(message: Message, info: SessionInfo): boolean;
+export declare function publicationMessage(publication: TopicUpdate, awaitRelease: boolean): Message;
+export {};

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

@@ -0,0 +1,9 @@
+import type { SessionInfo } from "../types.ts";
+export declare function canSeeSession(from: SessionInfo, target: SessionInfo): boolean;
+export declare function assertMainParent(session: Omit<SessionInfo, "id">, sessions: ReadonlyMap<string, {
+    readonly info: SessionInfo;
+}>): void;
+/** Preserve exact-ID precedence and case-insensitive duplicate-name ambiguity. */
+export declare function findSessions<T extends {
+    readonly info: SessionInfo;
+}>(sessions: ReadonlyMap<string, T>, nameOrId: string, fromId: string): T[];

package/dist/pi-intercom/connection.js

@@ -2,6 +2,7 @@ import { IntercomClient } from "./broker/client.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
 import { readLastMessage } from "./last-message.js";
 import { asError } from "./validation.js";
+import { RecoveryError } from "./tool-results.js";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.js";
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
@@ -93,6 +94,7 @@ export class IntercomConnection {
             this.client.updatePresence({
                 status: this.lifecycle.status(),
                 ...this.lifecycle.health(this.hooks.pendingAsks()),
+                applicationGuard: this.lifecycle.snapshot().applicationGuard ?? null,
             });
         }
     }
@@ -110,6 +112,10 @@ export class IntercomConnection {
                 return;
             }
             try {
+                if ("messageId" in request.query) {
+                    next.respondLast(request.requestId, this.hooks.receipt(request.query));
+                    return;
+                }
                 next.respondLast(request.requestId, readLastMessage(ctx.sessionManager, {
                     id,
                     ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
@@ -143,6 +149,7 @@ export class IntercomConnection {
             }
             this.hooks.disconnected(error);
             this.client = null;
+            this.lifecycle.transport(null);
             this.clearReconnect();
             this.scheduleReconnect();
         });
@@ -161,6 +168,7 @@ export class IntercomConnection {
                 throw new Error("Intercom runtime no longer active");
             }
             this.client = next;
+            this.lifecycle.transport(next.sessionId, next.supportsGuardedDelivery);
             this.syncIdentity(ctx.sessionManager.getSessionId());
             this.attempt = 0;
             return next;
@@ -239,10 +247,10 @@ export async function resolveConnectedTarget(active, name) {
         return resolution.target.id;
     }
     if (resolution.status === "ambiguous") {
-        throw new Error(`Target "${name}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`);
+        throw new RecoveryError("ambiguous_target", `Target "${name}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`);
     }
     if (resolution.status === "prefix_too_short") {
-        throw new Error(`Target "${name}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`);
+        throw new RecoveryError("ambiguous_target", `Target "${name}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`);
     }
     return null;
 }

package/dist/pi-intercom/identity.js

@@ -1,15 +1,16 @@
+// Launches set both variables to the parent's exact native session ID. Absence means a main;
+// anything else is refused, never normalized into a different identity.
 export function readIntercomLineage() {
-    const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID?.trim();
-    const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID?.trim();
+    const rootSessionId = process.env.PI_INTERCOM_ROOT_SESSION_ID;
+    const parentSessionId = process.env.PI_INTERCOM_PARENT_SESSION_ID;
     if (rootSessionId === undefined && parentSessionId === undefined) {
         return;
     }
     if (rootSessionId === undefined ||
-        parentSessionId === undefined ||
         rootSessionId === "" ||
-        parentSessionId === "" ||
+        rootSessionId !== rootSessionId.trim() ||
         rootSessionId !== parentSessionId) {
-        throw new Error("Intercom child launch requires matching root and parent native session IDs.");
+        throw new Error("Child launch requires identical, unpadded root and parent native session IDs.");
     }
     return { rootSessionId, parentSessionId };
 }

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

@@ -1,6 +1,4 @@
-import { randomUUID } from "node:crypto";
 import { requestedDelivery } from "./inbound-record.js";
-import { isRecord } from "./validation.js";
 import { runCooperatively } from "../shared/cooperative.js";
 /** Owns cooperative inbound batches, restoration and the flush timer. */
 export class InboundDeliveryOwner {
@@ -83,6 +81,9 @@ export class InboundDeliveryOwner {
         this.timer.unref();
     }
     queue(entry, flushDelivery = "auto", delayMs = 200) {
+        if (!this.journal.owns(entry)) {
+            return;
+        }
         this.journal.remember(entry, "queued", flushDelivery);
         this.hooks.syncStatus();
         this.schedule(delayMs);
@@ -112,8 +113,7 @@ export class InboundDeliveryOwner {
     }
     triggerIndex(entries) {
         const canTrigger = (entry) => entry.flushDelivery !== "passive" && requestedDelivery(entry.message) !== "passive";
-        const ask = entries.findIndex((entry) => canTrigger(entry) && entry.message.expectsReply === true);
-        return ask === -1 ? entries.findIndex(canTrigger) : ask;
+        return entries.findLastIndex(canTrigger);
     }
     *sendTriggerLast(entries, generation) {
         const passives = entries.filter((entry) => entry.flushDelivery === "passive");
@@ -124,14 +124,15 @@ export class InboundDeliveryOwner {
         }
         const index = this.triggerIndex(rest);
         const trigger = index === -1 ? undefined : rest.splice(index, 1)[0];
-        if (trigger && this.journal.get(trigger.message.id) === trigger) {
-            this.hooks.replies.queueTurnContext({ ...trigger, receivedAt: Date.now() });
+        const replyTarget = entries.find((entry) => entry.message.expectsReply === true) ?? trigger;
+        if (replyTarget && this.journal.get(replyTarget.message.id) === replyTarget) {
+            this.hooks.replies.queueTurnContext({ ...replyTarget, receivedAt: Date.now() });
         }
         for (const entry of rest) {
             if (!this.live(generation)) {
                 return;
             }
-            this.send(entry, entry.flushDelivery === "steer" ? "steer" : "followUp", generation);
+            this.send(entry, requestedDelivery(entry.message) === "queue" ? "followUp" : "steer", generation);
             yield;
         }
         if (trigger) {
@@ -150,7 +151,7 @@ export class InboundDeliveryOwner {
     live(generation) {
         return this.lifecycle.generation === generation && this.lifecycle.live() !== null;
     }
-    *sendSteers(entries, generation, onDetach) {
+    *sendSteers(entries, generation) {
         for (const entry of entries) {
             if (!this.live(generation)) {
                 return;
@@ -159,9 +160,6 @@ export class InboundDeliveryOwner {
                 continue;
             }
             this.send(entry, "steer", generation);
-            if (requestedDelivery(entry.message) === "steer") {
-                onDetach(this.detach(entry, entry.message.expectsReply !== true));
-            }
             yield;
         }
     }
@@ -184,13 +182,7 @@ export class InboundDeliveryOwner {
             this.schedule(500);
             return;
         }
-        return this.runBatch(async () => {
-            const detachments = [];
-            await runCooperatively(this.sendSteers(steers, generation, (task) => {
-                detachments.push(task);
-            }));
-            await Promise.all(detachments);
-        }, generation);
+        return this.runBatch(() => runCooperatively(this.sendSteers(steers, generation)), generation);
     }
     messageOptions(delivery) {
         if (delivery === "trigger") {
@@ -229,56 +221,20 @@ export class InboundDeliveryOwner {
         }
     }
     nativeMessage(entry) {
-        const sender = entry.from.name === undefined || entry.from.name === ""
-            ? entry.from.id.slice(0, 8)
-            : entry.from.name;
+        const sender = entry.from.name ?? entry.from.id.slice(0, 8);
         const command = entry.replyCommand ?? "";
         const reply = command === "" ? "" : `\n\nTo reply, use the intercom tool: ${command}`;
+        const hint = entry.message.replyHint;
+        const publication = hint
+            ? `\n\nTo publish a correlated reply, use ${hint.tool} with commandId ${hint.commandId}. This is not an intercom ask.`
+            : "";
         return {
             customType: "intercom_message",
-            content: `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}\n\n${entry.bodyText}`,
+            content: `**📨 From ${sender}** (Native session cwd: ${entry.from.cwd})${reply}${publication}\n\n${entry.bodyText}`,
             display: true,
             details: { ...entry, bodyText: entry.bodyText },
         };
     }
-    async detach(entry, attention = false) {
-        if (!attention && entry.message.expectsReply !== true) {
-            return false;
-        }
-        const requestId = randomUUID();
-        return await new Promise((resolve) => {
-            let settled = false;
-            const finish = (accepted) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                clearTimeout(timer);
-                unsubscribe();
-                resolve(accepted);
-            };
-            const timer = setTimeout(() => finish(false), 500);
-            timer.unref();
-            const unsubscribe = this.pi.events.on("pi-intercom:detach-response", (payload) => {
-                if (isRecord(payload) && payload.requestId === requestId) {
-                    finish(payload.accepted === true);
-                }
-            });
-            try {
-                this.pi.events.emit("pi-intercom:detach-request", {
-                    requestId,
-                    ...(attention ? { reason: "attention" } : {}),
-                });
-                // Owned waits answer ordinary attention synchronously; an unanswered probe completes now.
-                if (attention) {
-                    finish(false);
-                }
-            }
-            catch {
-                finish(false);
-            }
-        });
-    }
     async redeliver(ctx, generation) {
         if (this.batchTask) {
             await this.batchTask;