@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/pi-intercom/index.js

@@ -1,2942 +1,88 @@
-import { createHash } from "node:crypto";
-import { keyText } from "@earendil-works/pi-coding-agent";
-import { randomUUID } from "crypto";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "../shared/native-typebox.js";
-import { MouseRegion, Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { IntercomClient } from "./broker/client.js";
-import { isBrokerRunning, spawnBrokerIfNeeded } from "./broker/spawn.js";
-import { SessionListOverlay } from "./ui/session-list.js";
-import { ComposeOverlay } from "./ui/compose.js";
-import { InlineMessageComponent } from "./ui/inline-message.js";
 import { loadConfig } from "./config.js";
-import { isTopicSubscription, isTopicUpdate } from "./types.js";
+import { readChildOrchestratorMetadata } from "./identity.js";
+import { ReplyTracker } from "./reply-tracker.js";
 import { IntercomTopics } from "./topics.js";
-import { isDurableSupervisorQuestion, ReplyTracker } from "./reply-tracker.js";
-import { filterProjectSessions, formatPeerAwarenessHint, formatSessionTarget, formatTargetOptions, PEER_AWARENESS_HINT, resolveSessionProjectId, targetDisplayName, resolveSessionTarget as resolveSessionTargetValue } from "./session-targets.js";
-import { registerSubagentLiveEventHandlers } from "./subagent-live-events.js";
-import { formatRunAction } from "../shared/status-format.js";
-import { setPromptSection } from "../shared/prompt-sections.js";
-import { activateTools, restoreLazyTools } from "../shared/lazy-tools.js";
-import { runCooperatively } from "../shared/cooperative.js";
-import { cancelSupervisorQuestion, createSupervisorQuestion, getRunMetadataDir, listSupervisorQuestionsAsync, readRunJson, readQuestionState, recordQuestionDelivery, saveQuestionAnswer } from "../runs/shared/supervisor-questions.js";
-const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
-const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
-const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
-const SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT = "subagent:intercom-identity-request";
-const SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT = "subagent:intercom-identity-response";
-const SUBAGENT_SUPERVISOR_QUESTION_RESOLVED_EVENT = "subagent:supervisor-question-resolved";
-const INBOUND_CHECKPOINT_TYPE = "intercom_delivery";
-const INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
-const INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
-const INTERCOM_DETACH_RESPONSE_TIMEOUT_MS = 500;
-const INBOUND_FLUSH_DELAY_MS = 200;
-const INBOUND_IDLE_RETRY_MS = 500;
-const NON_UI_REPLACE_FLUSH_DELAY_MS = 1_600;
-const PEER_AWARENESS_LIST_TIMEOUT_MS = 75;
-const DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat";
-const RECIPIENT_TURN_FAILED_PREFIX = "Recipient turn failed:";
-const RECIPIENT_TURN_FAILED_ATTACHMENT = "pi-intercom-recipient-turn-failure";
-const SUBAGENT_ORCHESTRATOR_TARGET_ENV = "PI_SUBAGENT_ORCHESTRATOR_TARGET";
-const SUBAGENT_RUN_ID_ENV = "PI_SUBAGENT_RUN_ID";
-const SUBAGENT_CHILD_AGENT_ENV = "PI_SUBAGENT_CHILD_AGENT";
-const SUBAGENT_CHILD_INDEX_ENV = "PI_SUBAGENT_CHILD_INDEX";
-const SUBAGENT_INTERCOM_SESSION_NAME_ENV = "PI_SUBAGENT_INTERCOM_SESSION_NAME";
-const PACKAGE_ROOT = fileURLToPath(new URL("../../", import.meta.url));
-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.";
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function toError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}
-function failureDetails(reasonCode, nextActions, details = {}) {
-    return { ...details, reasonCode, nextActions };
-}
-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";
-    return "reply_failed";
-}
-function inboundIdFromCustomMessage(message) {
-    if (typeof message !== "object" || message === null)
-        return undefined;
-    const record = message;
-    if (record.customType !== "intercom_message" && record.customType !== "subagent-human-message")
-        return undefined;
-    const details = record.details;
-    if (typeof details !== "object" || details === null)
-        return undefined;
-    const inboundId = details.message?.id;
-    return typeof inboundId === "string" ? inboundId : undefined;
-}
-function getAssistantErrorMessage(message) {
-    if (typeof message !== "object" || message === null) {
-        return null;
-    }
-    const record = message;
-    if (record.role !== "assistant") {
-        return null;
-    }
-    const errorMessage = typeof record.errorMessage === "string" && record.errorMessage.trim()
-        ? record.errorMessage.trim()
-        : undefined;
-    if (record.stopReason === "error") {
-        return errorMessage ?? "assistant turn failed";
-    }
-    return null;
-}
-function formatAttachments(attachments) {
-    let text = "";
-    for (const att of attachments) {
-        if (att.language) {
-            text += `\n\n---\n📎 ${att.name}\n~~~${att.language}\n${att.content}\n~~~`;
-        }
-        else {
-            text += `\n\n---\n📎 ${att.name}\n${att.content}`;
-        }
-    }
-    return text;
-}
-function readChildOrchestratorMetadata() {
-    const orchestratorTarget = process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV]?.trim();
-    const runId = process.env[SUBAGENT_RUN_ID_ENV]?.trim();
-    const agent = process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim();
-    const index = process.env[SUBAGENT_CHILD_INDEX_ENV]?.trim();
-    if (!orchestratorTarget || !runId || !agent || !index) {
-        return null;
-    }
-    const sessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
-    return {
-        orchestratorTarget,
-        runId,
-        agent,
-        index,
-        ...(sessionName ? { sessionName } : {}),
-    };
-}
-function formatChildOrchestratorMessage(kind, metadata, message) {
-    const heading = kind === "ask"
-        ? "Subagent needs a supervisor decision."
-        : kind === "interview"
-            ? "Subagent requests a structured supervisor interview."
-            : "Subagent progress update.";
-    return [
-        heading,
-        `Run: ${metadata.runId}`,
-        `Agent: ${metadata.agent}`,
-        `Child index: ${metadata.index}`,
-        metadata.sessionName ? `Child intercom target: ${metadata.sessionName}` : undefined,
-        "",
-        message,
-    ].filter((line) => line !== undefined).join("\n");
-}
-function validateSupervisorInterviewRequest(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { ok: false, error: "interview must be an object with a questions array" };
-    }
-    const raw = input;
-    if (raw.title !== undefined && typeof raw.title !== "string") {
-        return { ok: false, error: "interview.title must be a string when provided" };
-    }
-    if (raw.description !== undefined && typeof raw.description !== "string") {
-        return { ok: false, error: "interview.description must be a string when provided" };
-    }
-    if (!Array.isArray(raw.questions) || raw.questions.length === 0) {
-        return { ok: false, error: "interview.questions must be a non-empty array" };
-    }
-    const validTypes = new Set(["single", "multi", "text", "image", "info"]);
-    const ids = new Set();
-    const questions = [];
-    for (let index = 0; index < raw.questions.length; index++) {
-        const questionInput = raw.questions[index];
-        if (!questionInput || typeof questionInput !== "object" || Array.isArray(questionInput)) {
-            return { ok: false, error: `interview.questions[${index}] must be an object` };
-        }
-        const question = questionInput;
-        if (typeof question.id !== "string" || question.id.trim() === "") {
-            return { ok: false, error: `interview.questions[${index}].id must be a non-empty string` };
-        }
-        const id = question.id.trim();
-        if (ids.has(id)) {
-            return { ok: false, error: `interview question id must be unique: ${id}` };
-        }
-        ids.add(id);
-        if (typeof question.type !== "string" || !validTypes.has(question.type)) {
-            return { ok: false, error: `interview.questions[${index}].type must be one of: single, multi, text, image, info` };
-        }
-        if (typeof question.question !== "string" || question.question.trim() === "") {
-            return { ok: false, error: `interview.questions[${index}].question must be a non-empty string` };
-        }
-        if (question.context !== undefined && typeof question.context !== "string") {
-            return { ok: false, error: `interview.questions[${index}].context must be a string when provided` };
-        }
-        let options;
-        if (question.options !== undefined) {
-            if (!Array.isArray(question.options)) {
-                return { ok: false, error: `interview.questions[${index}].options must be an array when provided` };
-            }
-            options = [];
-            for (let optionIndex = 0; optionIndex < question.options.length; optionIndex++) {
-                const option = question.options[optionIndex];
-                if (typeof option === "string") {
-                    const label = option.trim();
-                    if (!label) {
-                        return { ok: false, error: `interview.questions[${index}].options[${optionIndex}] must not be empty` };
-                    }
-                    options.push(label);
-                }
-                else if (!option || typeof option !== "object" || Array.isArray(option) || typeof option.label !== "string" || option.label.trim() === "") {
-                    return { ok: false, error: `interview.questions[${index}].options[${optionIndex}] must be a non-empty string or an object with a non-empty label` };
-                }
-                else {
-                    options.push({ ...option, label: option.label.trim() });
-                }
-            }
-        }
-        if ((question.type === "single" || question.type === "multi") && (!options || options.length === 0)) {
-            return { ok: false, error: `interview.questions[${index}].options must be a non-empty array for ${question.type} questions` };
-        }
-        if (question.type !== "single" && question.type !== "multi" && options) {
-            return { ok: false, error: `interview.questions[${index}].options is only valid for single and multi questions` };
-        }
-        questions.push({
-            ...question,
-            id,
-            type: question.type,
-            question: question.question.trim(),
-            ...(options ? { options } : {}),
-        });
-    }
-    return {
-        ok: true,
-        interview: {
-            ...raw,
-            ...(typeof raw.title === "string" ? { title: raw.title.trim() } : {}),
-            ...(typeof raw.description === "string" ? { description: raw.description.trim() } : {}),
-            questions,
-        },
-    };
-}
-function interviewOptionLabel(option) {
-    return typeof option === "string" ? option : option.label;
-}
-function interviewExampleValue(question) {
-    if (question.type === "multi") {
-        return question.options?.slice(0, 2).map(interviewOptionLabel) ?? [];
-    }
-    if (question.type === "single") {
-        return question.options?.[0] !== undefined ? interviewOptionLabel(question.options[0]) : "option label";
-    }
-    if (question.type === "image") {
-        return "image/file reference or description";
-    }
-    return "answer text";
-}
-function formatSupervisorInterviewRequest(interview, message) {
-    const lines = [];
-    const title = interview.title?.trim();
-    if (title)
-        lines.push(`Interview: ${title}`);
-    const description = interview.description?.trim();
-    if (description)
-        lines.push(description);
-    const note = message?.trim();
-    if (note)
-        lines.push(`Child note: ${note}`);
-    if (lines.length > 0)
-        lines.push("");
-    lines.push("Questions:");
-    interview.questions.forEach((question, index) => {
-        lines.push(`${index + 1}. [${question.id}] (${question.type}) ${question.question}`);
-        if (typeof question.context === "string" && question.context.trim()) {
-            lines.push(`   Context: ${question.context.trim()}`);
-        }
-        if (question.options?.length) {
-            lines.push("   Options:");
-            for (const option of question.options) {
-                lines.push(`   - ${interviewOptionLabel(option)}`);
-            }
-        }
-    });
-    const responseExample = {
-        responses: interview.questions
-            .filter((question) => question.type !== "info")
-            .map((question) => ({
-            id: question.id,
-            value: interviewExampleValue(question),
-        })),
-    };
-    lines.push("", "Supervisor reply instructions:", "Reply with plain JSON or a fenced ```json block using this stable shape. Use the question ids exactly. Info questions are context-only and do not need responses. For single questions, value is one option label. For multi questions, value is an array of option labels. For text/image questions, value is a string unless the question asks otherwise.", "", "```json", JSON.stringify(responseExample, null, 2), "```");
-    return lines.join("\n");
-}
-function validateSupervisorInterviewReply(value, interview) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("reply JSON must be an object with a responses array");
-    }
-    const responsesInput = value.responses;
-    if (!Array.isArray(responsesInput)) {
-        throw new Error("reply JSON must include a responses array");
-    }
-    const questionById = new Map(interview.questions
-        .filter((question) => question.type !== "info")
-        .map((question) => [question.id, question]));
-    const seenIds = new Set();
-    const responses = [];
-    for (let index = 0; index < responsesInput.length; index++) {
-        const response = responsesInput[index];
-        if (!response || typeof response !== "object" || Array.isArray(response)) {
-            throw new Error(`responses[${index}] must be an object`);
-        }
-        const raw = response;
-        if (typeof raw.id !== "string" || raw.id.trim() === "") {
-            throw new Error(`responses[${index}].id must be a non-empty string`);
-        }
-        const id = raw.id.trim();
-        const question = questionById.get(id);
-        if (!question) {
-            throw new Error(`responses[${index}].id must match a non-info interview question id`);
-        }
-        if (seenIds.has(id)) {
-            throw new Error(`responses[${index}].id is duplicated: ${id}`);
-        }
-        seenIds.add(id);
-        if (!Object.hasOwn(raw, "value")) {
-            throw new Error(`responses[${index}].value is required`);
-        }
-        const value = raw.value;
-        if (question.type === "single") {
-            if (typeof value !== "string")
-                throw new Error(`responses[${index}].value must be a string for single questions`);
-            const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-            if (!optionLabels.has(value.trim()))
-                throw new Error(`responses[${index}].value must match one of the question options`);
-            responses.push({ id, value: value.trim() });
-            continue;
-        }
-        if (question.type === "multi") {
-            if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-                throw new Error(`responses[${index}].value must be an array of strings for multi questions`);
-            }
-            const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-            const selected = value.map((item) => item.trim());
-            const invalid = selected.find((item) => !optionLabels.has(item));
-            if (invalid)
-                throw new Error(`responses[${index}].value contains an option that is not in the question options: ${invalid}`);
-            responses.push({ id, value: selected });
-            continue;
-        }
-        if (typeof value !== "string") {
-            throw new Error(`responses[${index}].value must be a string for ${question.type} questions`);
-        }
-        responses.push({ id, value });
-    }
-    return { responses };
-}
-function parseStructuredSupervisorReply(text, interview) {
-    const fencedMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    const candidate = (fencedMatch?.[1] ?? text).trim();
-    if (!candidate.startsWith("{") && !candidate.startsWith("[")) {
-        return undefined;
-    }
-    try {
-        return { value: validateSupervisorInterviewReply(JSON.parse(candidate), interview) };
-    }
-    catch (error) {
-        return { error: getErrorMessage(error) };
-    }
-}
-function duplicateSessionNames(sessions) {
-    return new Set(sessions
-        .map(s => s.name?.toLowerCase())
-        .filter((name) => Boolean(name))
-        .filter((name, index, names) => names.indexOf(name) !== index));
-}
-function parseSubagentIntercomPayload(payload) {
-    if (typeof payload !== "object" || payload === null) {
-        return null;
-    }
-    const record = payload;
-    if (typeof record.to !== "string" || typeof record.message !== "string") {
-        return null;
-    }
-    const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
-    const source = record.source === "foreground" || record.source === "async" ? record.source : undefined;
-    const children = Array.isArray(record.children) ? record.children.flatMap((value) => {
-        if (!value || typeof value !== "object")
-            return [];
-        const child = value;
-        return typeof child.agent === "string" && typeof child.index === "number" && Number.isSafeInteger(child.index) && child.index >= 0
-            && typeof child.intercomTarget === "string" && child.intercomTarget.length > 0 && typeof child.status === "string"
-            && ["completed", "failed", "blocked", "paused", "timed-out", "detached"].includes(child.status)
-            ? [{ agent: child.agent, index: child.index, status: child.status, intercomTarget: child.intercomTarget }] : [];
-    }) : [];
-    const completion = source && typeof record.runId === "string" && typeof record.status === "string" && children.length
-        ? { runId: record.runId, status: record.status, children, ...(typeof record.completionId === "string" ? { completionId: record.completionId } : {}) } : undefined;
-    return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}), ...(source ? { source } : {}), ...(completion ? { completion } : {}) };
-}
-function resolveIntercomPresenceName(sessionName, sessionId) {
-    const trimmedName = sessionName?.trim();
-    if (trimmedName) {
-        return trimmedName;
-    }
-    const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-    return `${DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
-}
-function buildPresenceIdentity(pi, sessionId) {
-    const subagentIntercomSessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
-    return {
-        name: subagentIntercomSessionName || resolveIntercomPresenceName(pi.getSessionName(), sessionId),
-    };
-}
-function formatDuration(seconds) {
-    if (seconds < 60)
-        return `${seconds}s`;
-    if (seconds < 3600)
-        return `${Math.floor(seconds / 60)}m`;
-    return `${Math.floor(seconds / 3600)}h`;
-}
-function sessionBusyState(session) {
-    if (session.acceptsAsks === true)
-        return "idle";
-    if (session.acceptsAsks === false)
-        return "busy";
-    const status = session.status ?? "";
-    if (status === "idle" || status.startsWith("idle ") || status.startsWith("idle ·"))
-        return "idle";
-    if (status === "thinking" || status.startsWith("thinking ") || status.startsWith("thinking ·") || status.startsWith("tool:"))
-        return "busy";
-    return "unknown";
-}
-function formatIntercomAge(timestamp, now) {
-    return typeof timestamp === "number" && timestamp > 0
-        ? `${formatDuration(Math.max(0, Math.floor((now - timestamp) / 1000)))} ago`
-        : "none";
-}
-function sessionDeliveryGuidance(session, isSelf) {
-    if (isSelf)
-        return "self target unavailable; choose a peer from Other sessions; use pending/reply for inbound asks";
-    const state = sessionBusyState(session);
-    if (state === "idle")
-        return "send defaults to steer and wakes; ask only if sender must stay alive for a required reply; queue only for intentional delay; passive discouraged";
-    if (session.acceptsAsks === false)
-        return "send defaults to steer; ask only if sender must stay alive for a required reply (default sends without waiting when peer is busy); queue only for intentional delay; passive discouraged";
-    if (state === "busy")
-        return "send defaults to steer at the next tool boundary; ask only if sender must stay alive for a required reply; queue only for intentional delay; passive discouraged";
-    return "state unknown; target is valid; send defaults to steer; ask only if sender must stay alive for a required reply; queue only for intentional delay; passive discouraged";
-}
-function formatSessionListRow(session, currentCwd, isSelf, duplicates = new Set(), allSessions = [session], now = Date.now()) {
-    const name = session.name || "Unnamed session";
-    const duplicateName = Boolean(session.name && duplicates.has(session.name.toLowerCase()));
-    const healthTags = [];
-    healthTags.push(`state:${sessionBusyState(session)}`);
-    healthTags.push(`accepts_asks:${session.acceptsAsks === undefined ? "unknown" : session.acceptsAsks ? "true" : "false"}`);
-    healthTags.push(`pending_asks:${typeof session.pendingAsks === "number" ? session.pendingAsks : "unknown"}`);
-    healthTags.push(`last_intercom_activity:${formatIntercomAge(session.lastIntercomActivity, now)}`);
-    if (typeof session.lastSeen === "number") {
-        healthTags.push(`last_seen:${formatDuration(Math.max(0, Math.floor((now - session.lastSeen) / 1000)))} ago`);
-    }
-    const tags = [
-        isSelf ? "self" : session.cwd === currentCwd ? "same native session cwd" : undefined,
-        session.status,
-        duplicateName ? `target:${formatSessionTarget(session, allSessions)}` : undefined,
-        ...healthTags,
-    ].filter((tag) => Boolean(tag));
-    const target = formatSessionTarget(session, allSessions);
-    const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
-    return `• ${name} (${target}) — Native session cwd: ${session.cwd} (${session.model})${suffix}\n  ↳ ${sessionDeliveryGuidance(session, isSelf)}`;
-}
-function sessionsForScope(sessions, currentSessionId, scope) {
-    return scope === "all" ? sessions : filterProjectSessions(sessions, currentSessionId);
-}
-function formatSessionListSections(allSessions, currentSessionId, scope = "project") {
-    const currentSession = allSessions.find(s => s.id === currentSessionId);
-    if (!currentSession) {
-        throw new Error("Current session is missing from intercom session list.");
-    }
-    const sessions = sessionsForScope(allSessions, currentSessionId, scope);
-    const hiddenSessionCount = allSessions.length - sessions.length;
-    const duplicates = duplicateSessionNames(allSessions);
-    const otherSessions = sessions.filter(s => s.id !== currentSessionId);
-    const currentSection = `**Current session:**\n${formatSessionListRow(currentSession, currentSession.cwd, true, duplicates, allSessions)}`;
-    const otherSection = otherSessions.length === 0
-        ? `**Other sessions:**\n${hiddenSessionCount > 0
-            ? "No other sessions connected in this project."
-            : `No other sessions connected. Start another intercom-enabled session with \`pi --name worker\`, then run \`intercom({ action: "list" })\` again. If you are dogfooding this local fork without installing it, start the peer with \`${localForkStartCommand()}\`.`}`
-        : `**Other sessions:**\n${otherSessions.map(s => formatSessionListRow(s, currentSession.cwd, false, duplicates, allSessions)).join("\n")}`;
-    const scopeHint = hiddenSessionCount > 0
-        ? `\n\n${hiddenSessionCount} session${hiddenSessionCount === 1 ? "" : "s"} in other projects hidden. Use \`intercom({ action: "list", scope: "all" })\` to show every connected session.`
-        : "";
-    return `${currentSection}\n\n${otherSection}${scopeHint}`;
-}
-function previewText(value, maxLength = 72) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const normalized = value.replace(/\s+/g, " ").trim();
-    if (!normalized) {
-        return undefined;
-    }
-    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
-}
-function pendingAskPreview(message) {
-    const text = message.content.text;
-    const normalized = text.replace(/\s+/g, " ").trim();
-    if (text.startsWith("Subagent needs a supervisor decision.") || text.startsWith("Subagent requests a structured supervisor interview.")) {
-        const run = text.match(/^Run:\s*(.+)$/m)?.[1]?.trim();
-        const agent = text.match(/^Agent:\s*(.+)$/m)?.[1]?.trim();
-        const childTarget = text.match(/^Child intercom target:\s*(.+)$/m)?.[1]?.trim();
-        const body = text.split(/\n\s*\n/).slice(1).join(" ").replace(/\s+/g, " ").trim();
-        return [
-            text.startsWith("Subagent requests") ? "structured supervisor interview" : "supervisor decision",
-            run ? `run=${run}` : undefined,
-            agent ? `agent=${agent}` : undefined,
-            childTarget ? `target=${childTarget}` : undefined,
-            body ? `question=${previewText(body, 180)}` : undefined,
-        ].filter((part) => Boolean(part)).join(" · ");
-    }
-    return previewText(normalized, 180) ?? normalized;
-}
-function firstTextContent(result) {
-    return result.content?.find((item) => item.type === "text" && typeof item.text === "string")?.text?.replace(/\*\*/g, "") ?? "";
-}
-class ToolExecutionFailure extends Error {
-    details;
-    constructor(message, details) {
-        super(message);
-        this.details = details;
-    }
-}
-class AskDeliveryError extends Error {
-    result;
-    constructor(result) {
-        super(result.reason ?? "Session may not exist or has disconnected.");
-        this.result = result;
-    }
-}
-function throwIfToolError(result) {
-    if (!result.isError)
-        return result;
-    throw new ToolExecutionFailure(firstTextContent(result) || "Tool failed", result.details);
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function localForkStartCommand() {
-    return `pi --name worker --extension ${shellQuote(fileURLToPath(import.meta.url))} --skill ${shellQuote(path.join(PACKAGE_ROOT, "skills", "pi-intercom"))}`;
-}
-async function settleWithin(operation, timeoutMs) {
-    return await new Promise((resolve) => {
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve(value);
-        };
-        const timer = setTimeout(() => finish(null), timeoutMs);
-        timer.unref?.();
-        void Promise.resolve().then(operation).then((value) => finish(value), () => finish(null));
-    });
-}
+import { IntercomLifecycle } from "./lifecycle.js";
+import { InboundJournal } from "./inbound-journal.js";
+import { InboundDeliveryOwner } from "./inbound-delivery.js";
+import { ReplyWait } from "./reply-wait.js";
+import { IntercomConnection } from "./connection.js";
+import { IntercomInbound } from "./inbound.js";
+import { IntercomOutbound } from "./outbound.js";
+import { IntercomInspection } from "./inspection.js";
+import { IntercomTopicActions } from "./topic-actions.js";
+import { IntercomSupervisor } from "./supervisor.js";
+import { IntercomTools } from "./tools.js";
+import { IntercomOverlay } from "./ui/overlay.js";
+import { SubagentEventBridges } from "./subagent-events.js";
+import { IntercomSessionEvents } from "./session-events.js";
+import { PeerAwareness } from "./peer-awareness.js";
+import { registerMessageRenderers } from "./ui/message-renderers.js";
+import { registerIntercomTools } from "./tool-registration.js";
 export default function piIntercomExtension(pi) {
-    let client = null;
     const config = loadConfig();
-    const childOrchestratorMetadata = readChildOrchestratorMetadata();
-    let runtimeContext = null;
-    let currentSessionId = null;
-    let currentModel = "unknown";
-    let reconnectTimer = null;
-    let reconnectPromise = null;
-    let reconnectPromiseGeneration = null;
-    let startupConnectTimer = null;
-    let reconnectAttempt = 0;
-    let disposed = true;
-    let runtimeStarted = false;
-    let runtimeGeneration = 0;
-    // Once peers have been seen, the hint is pinned for the rest of the session:
-    // the identical string is re-appended on every turn without another broker
-    // round trip. This keeps the system prompt byte-stable across fleet churn
-    // (session spawns/exits, subagent panels), which keeps the provider prompt
-    // cache valid; the hint text is written so it stays true after peers exit.
-    let peerAwarenessHintPinned = false;
-    let agentRunning = false;
-    let lastIntercomActivity = 0;
-    const activeTools = new Map();
-    const replyTracker = new ReplyTracker(config.askTimeoutMs);
-    const topics = new IntercomTopics(pi, () => getLiveContext());
-    let topicSyncError;
-    const pendingInbound = new Map();
-    const nativePendingIds = new Set();
-    const consumedInboundIds = new Set();
-    const completedChildren = new Map();
-    let reconciledLeafId = null;
-    let inboundFlushTimer = null;
-    let inboundRestore;
-    let inboundBatch;
-    let replyWaiter = null;
-    function waitForReply(from, replyTo, signal, question) {
-        if (replyWaiter) {
-            throw new Error("Already waiting for a reply");
-        }
-        if (signal?.aborted) {
-            throw new Error("Cancelled");
-        }
-        return new Promise((resolve, reject) => {
-            const timeout = question ? undefined : setTimeout(() => {
-                rejectReplyWaiter(new Error(`No reply from "${from}" within ${Math.max(1, Math.round(config.askTimeoutMs / 60000))} minute(s)`));
-            }, config.askTimeoutMs);
-            timeout?.unref?.();
-            const poll = question ? setInterval(() => {
-                try {
-                    const saved = readQuestionState(question);
-                    if (saved.state === "cancelled") {
-                        getLiveContext()?.abort();
-                        return rejectReplyWaiter(new Error("Cancelled"));
-                    }
-                    if (saved.answer)
-                        replyWaiter?.resolve({ id: replyTo, replyTo, timestamp: saved.answer.answeredAt, content: { text: saved.answer.message } });
-                    else
-                        replyWaiter?.retryNotification?.();
-                }
-                catch (error) {
-                    rejectReplyWaiter(toError(error));
-                }
-            }, 250) : undefined;
-            const cleanup = () => {
-                clearTimeout(timeout);
-                clearInterval(poll);
-                signal?.removeEventListener("abort", onAbort);
-                if (replyWaiter?.replyTo === replyTo) {
-                    replyWaiter = null;
-                }
-            };
-            const onAbort = () => {
-                try {
-                    if (question)
-                        cancelSupervisorQuestion(question);
-                }
-                finally {
-                    cleanup();
-                    reject(new Error("Cancelled"));
-                }
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
-            replyWaiter = {
-                from,
-                replyTo,
-                question,
-                resolve: (message) => {
-                    if (question && message.content.attachments?.some((attachment) => attachment.name === RECIPIENT_TURN_FAILED_ATTACHMENT)) {
-                        pi.appendEntry("intercom_question_notification_error", { questionId: question.questionId, error: message.content.text });
-                        return;
-                    }
-                    try {
-                        if (question)
-                            saveQuestionAnswer(question, message.content.text);
-                        cleanup();
-                        resolve(message);
-                    }
-                    catch (error) {
-                        cleanup();
-                        reject(toError(error));
-                    }
-                },
-                reject: (error) => {
-                    cleanup();
-                    reject(error);
-                },
-            };
-        });
-    }
-    function currentReplyWaiter() { return replyWaiter; }
-    function rejectReplyWaiter(error) {
-        replyWaiter?.reject(error);
-    }
-    function rejectReplyWaiterForPeer(sessionId) {
-        if (replyWaiter?.from === sessionId && !replyWaiter.question) {
-            rejectReplyWaiter(new Error(`Reply peer disconnected before answering: ${sessionId}`));
-        }
-    }
-    async function sendAskTransaction(activeClient, to, questionId, options, signal, onSent) {
-        const replyPromise = waitForReply(to, questionId, signal);
-        replyPromise.catch(() => undefined);
-        try {
-            if (signal?.aborted)
-                throw new Error("Cancelled");
-            const result = await activeClient.send(to, { ...options, messageId: questionId, expectsReply: true });
-            if (!result.accepted)
-                throw new AskDeliveryError(result);
-            markIntercomActivity();
-            syncPresenceStatus();
-            onSent(result);
-            return await replyPromise;
-        }
-        catch (error) {
-            if (replyWaiter?.replyTo === questionId)
-                rejectReplyWaiter(toError(error));
-            try {
-                await replyPromise;
-            }
-            catch {
-                // Cleanup only; preserve the transaction failure.
-            }
-            throw error;
-        }
-    }
-    function clearReconnectTimer() {
-        if (!reconnectTimer) {
-            return;
-        }
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-    }
-    function clearStartupConnectTimer() {
-        if (!startupConnectTimer) {
-            return;
-        }
-        clearTimeout(startupConnectTimer);
-        startupConnectTimer = null;
-    }
-    function scheduleStartupConnection(ctx, generation) {
-        clearStartupConnectTimer();
-        startupConnectTimer = setTimeout(() => {
-            startupConnectTimer = null;
-            if (!getLiveContext(ctx, generation))
-                return;
-            void ensureConnected("startup").catch(() => {
-                if (!getLiveContext(ctx, generation))
-                    return;
-                client = null;
-                scheduleReconnect();
-            });
-        }, 0);
-        startupConnectTimer.unref?.();
-    }
-    function clearInboundFlushTimer() {
-        if (!inboundFlushTimer) {
-            return;
-        }
-        clearTimeout(inboundFlushTimer);
-        inboundFlushTimer = null;
-    }
-    function getLiveContext(ctx = runtimeContext, generation = runtimeGeneration) {
-        if (disposed || generation !== runtimeGeneration || !ctx) {
-            return null;
-        }
-        try {
-            if (currentSessionId && ctx.sessionManager.getSessionId() !== currentSessionId) {
-                return null;
-            }
-            void ctx.hasUI;
-            return ctx;
-        }
-        catch {
-            // A context that throws while reading session/UI state is no longer usable.
-            return null;
-        }
-    }
-    function notifyIfLive(ctx, message, level, generation = runtimeGeneration) {
-        const liveContext = getLiveContext(ctx, generation);
-        if (!liveContext?.hasUI) {
-            return;
-        }
-        try {
-            liveContext.ui.notify(message, level);
-        }
-        catch {
-            // The UI can disappear during session shutdown/reload while async overlay work is settling.
-        }
-    }
-    function getReconnectDelayMs() {
-        const backoffMs = [1000, 2000, 5000, 10000, 30000];
-        return backoffMs[Math.min(reconnectAttempt, backoffMs.length - 1)];
-    }
-    function currentStatus() {
-        const activeToolName = activeTools.values().next().value;
-        const lifecycleStatus = activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
-        return config.status ? `${lifecycleStatus} · ${config.status}` : lifecycleStatus;
-    }
-    async function buildRegistration() {
-        const liveContext = getLiveContext();
-        if (!liveContext || !currentSessionId) {
-            throw new Error("Intercom runtime not initialized");
-        }
-        const identity = buildPresenceIdentity(pi, currentSessionId);
-        const cwd = liveContext.cwd ?? process.cwd();
-        return {
-            name: identity.name,
-            cwd,
-            model: currentModel,
-            projectId: await resolveSessionProjectId(cwd),
-            lastSeen: Date.now(),
-            status: currentStatus(),
-            ...buildPresenceHealth(),
-        };
-    }
-    function isRecipientIdle(ctx) {
-        // ponytail: Pi 1.0 exposes no busy signal during foreign prompt preparation;
-        // custom delivery may start a separate legitimate run. Use a public admission
-        // signal if the host adds one, rather than reserving rejected input here.
-        if (agentRunning || activeTools.size > 0)
-            return false;
-        try {
-            return ctx.isIdle();
-        }
-        catch {
-            return false;
-        }
-    }
-    function canAcceptAsks() {
-        const liveContext = getLiveContext();
-        return liveContext ? isRecipientIdle(liveContext) : false;
-    }
-    /** Publish whether the recipient can accept a blocking ask. */
-    function buildPresenceHealth() {
-        return {
-            pendingAsks: replyTracker.listPending().length,
-            acceptsAsks: canAcceptAsks(),
-            lastIntercomActivity,
-        };
-    }
-    function markIntercomActivity() {
-        lastIntercomActivity = Date.now();
-    }
-    function syncPresenceIdentity(sessionId) {
-        if (!client || !getLiveContext()) {
-            return;
-        }
-        client.updatePresence({ ...buildPresenceIdentity(pi, sessionId), status: currentStatus(), ...buildPresenceHealth() });
-    }
-    function syncPresenceStatus() {
-        if (!client || !currentSessionId || !getLiveContext()) {
-            return;
-        }
-        client.updatePresence({ status: currentStatus(), ...buildPresenceHealth() });
-    }
-    function requestedDelivery(message) {
-        if (message.passive === true || message.delivery === "passive")
-            return "passive";
-        return message.delivery ?? (message.expectsReply === true ? "auto" : "steer");
-    }
-    function shouldTriggerTurn(message) {
-        return requestedDelivery(message) !== "passive";
-    }
-    function queuedTriggerIndex(entries) {
-        const canTrigger = (entry) => entry.flushDelivery !== "passive" && shouldTriggerTurn(entry.message);
-        const askIndex = entries.findIndex((entry) => canTrigger(entry) && entry.message.expectsReply === true);
-        return askIndex === -1 ? entries.findIndex(canTrigger) : askIndex;
-    }
-    function runInboundBatch(deliver, generation = runtimeGeneration) {
-        if (inboundBatch)
-            return inboundBatch;
-        // Native appends emit subscriber callbacks synchronously; publish ownership first.
-        const batch = Promise.resolve().then(deliver);
-        inboundBatch = batch;
-        const finish = () => {
-            if (inboundBatch !== batch)
-                return;
-            inboundBatch = undefined;
-            if (getLiveContext(runtimeContext, generation) && queuedInbound().length)
-                scheduleInboundFlush(0);
-        };
-        void batch.then(finish, finish);
-        return batch;
-    }
-    function* sendTriggerLast(entries, generation = runtimeGeneration) {
-        const passives = [];
-        const rest = [];
-        for (const entry of entries) {
-            if (entry.flushDelivery === "passive")
-                passives.push(entry);
-            else
-                rest.push(entry);
-        }
-        for (const entry of passives) {
-            if (!getLiveContext(runtimeContext, generation))
-                return;
-            sendIncomingMessage(entry, "passive", generation);
-            yield;
-        }
-        if (!getLiveContext(runtimeContext, generation))
-            return;
-        const triggerIndex = queuedTriggerIndex(rest);
-        const trigger = triggerIndex === -1 ? undefined : rest.splice(triggerIndex, 1)[0];
-        if (trigger && pendingInbound.get(trigger.message.id) === trigger)
-            replyTracker.queueTurnContext({ ...trigger, receivedAt: Date.now() });
-        for (const entry of rest) {
-            if (!getLiveContext(runtimeContext, generation))
-                return;
-            sendIncomingMessage(entry, entry.flushDelivery === "steer" ? "steer" : "followUp", generation);
-            yield;
-        }
-        if (trigger)
-            sendIncomingMessage(trigger, "trigger", generation);
-    }
-    function currentSessionTargetMatches(to, resolvedTo, activeClient) {
-        const targets = new Set();
-        const addTarget = (target) => {
-            const trimmed = target?.trim();
-            if (trimmed)
-                targets.add(trimmed.toLowerCase());
-        };
-        addTarget(currentSessionId);
-        addTarget(activeClient?.sessionId);
-        addTarget(pi.getSessionName());
-        if (currentSessionId)
-            addTarget(buildPresenceIdentity(pi, currentSessionId).name);
-        return Boolean(resolvedTo && activeClient?.sessionId && resolvedTo === activeClient.sessionId)
-            || targets.has(to.trim().toLowerCase());
-    }
-    function checkpointInbound(update) {
-        if (currentSessionId)
-            pi.appendEntry(INBOUND_CHECKPOINT_TYPE, { sessionId: currentSessionId, ...update });
-    }
-    function retireReply(messageId, stage = "reply-retired") {
-        replyTracker.markReplied(messageId);
-        checkpointInbound({ messageId, stage });
-    }
-    function keepInbound(entry) {
-        if (entry.stage === "queued" && entry.message.queueMode === "replace" && entry.message.threadId) {
-            for (const pending of pendingInbound.values()) {
-                if (pending.stage === "queued" && pending.from.id === entry.from.id && pending.message.threadId === entry.message.threadId) {
-                    pendingInbound.delete(pending.message.id);
-                    replyTracker.markReplied(pending.message.id);
-                }
-            }
-        }
-        pendingInbound.set(entry.message.id, entry);
-    }
-    function setInboundStage(entry, stage) {
-        if (entry.stage === stage)
-            return;
-        pendingInbound.set(entry.message.id, { ...entry, stage });
-        checkpointInbound({ messageId: entry.message.id, stage });
-    }
-    function rememberInbound(entry, stage, flushDelivery) {
-        const pending = pendingInbound.get(entry.message.id);
-        if (pending) {
-            setInboundStage(pending, stage);
-            return;
-        }
-        const saved = { ...entry, stage, flushDelivery, receivedAt: Date.now() };
-        keepInbound(saved);
-        checkpointInbound({ entry: saved });
-    }
-    function queuedInbound() {
-        return [...pendingInbound.values()].filter((entry) => entry.stage === "queued");
-    }
-    function rememberCompletedChildren(entry) {
-        const completion = entry.subagentCompletion;
-        if (entry.from.id !== "subagent-result" || completion?.ownerSessionId !== currentSessionId)
-            return;
-        for (const child of completion.children) {
-            const thread = `subagent-progress:${completion.runId}:${child.agent}:${child.index}`;
-            if (child.status === "detached")
-                completedChildren.delete(thread);
-            else
-                completedChildren.set(thread, child);
-        }
-        for (const pending of queuedInbound())
-            discardObsoleteProgress(pending);
-    }
-    function discardObsoleteProgress(entry) {
-        const message = entry.message;
-        if (message.delivery !== "queue" || message.queueMode !== "replace" || !message.threadId || message.expectsReply || message.replyTo)
-            return false;
-        const child = completedChildren.get(message.threadId);
-        if (!child || (entry.from.id !== child.intercomTarget && entry.from.name !== child.intercomTarget))
-            return false;
-        // Keep the original checkpoint as history; obsolete progress is not another model turn.
-        if (!pendingInbound.has(message.id))
-            rememberInbound(entry, "queued", "auto");
-        pendingInbound.delete(message.id);
-        replyTracker.markReplied(message.id);
-        checkpointInbound({ messageId: message.id, stage: "discarded" });
-        return true;
-    }
-    function needsIntercom(entry) {
-        return entry.message.human === undefined && shouldTriggerTurn(entry.message)
-            && entry.from.id !== "subagent-result" && entry.from.id !== "subagent-control";
-    }
-    function reconcileIntercom(ctx) {
-        if ([...pendingInbound.values()].some(needsIntercom) || replyTracker.listPending().some(needsIntercom))
-            activateTools(pi, ["intercom"]);
-    }
-    function* restoreInboundEntries(ctx, generation) {
-        consumedInboundIds.clear();
-        completedChildren.clear();
-        const leafId = ctx.sessionManager.getLeafId();
-        for (const metadata of ctx.sessionManager.getEntries()) {
-            yield;
-            if (!getLiveContext(ctx, generation))
-                return;
-            if (!(metadata.type === "custom_message" && ["intercom_message", "subagent-human-message"].includes(metadata.customType)
-                || metadata.type === "custom" && [INBOUND_CHECKPOINT_TYPE, "intercom_sent"].includes(metadata.customType)))
-                continue;
-            const item = ctx.sessionManager.getEntry(metadata.id) ?? metadata;
-            if (item.type === "custom_message") {
-                const receipt = item.details;
-                if (receipt?.subagentCompletion)
-                    rememberCompletedChildren(receipt);
-                const id = receipt && typeof receipt === "object" ? receipt.message?.id : undefined;
-                if (typeof id === "string") {
-                    consumedInboundIds.add(id);
-                    pendingInbound.delete(id);
-                }
-            }
-            else if (item.type === "custom" && item.customType === INBOUND_CHECKPOINT_TYPE) {
-                const data = item.data;
-                // Forks inherit entries, but pending delivery belongs to the saved session UUID.
-                if (data?.sessionId !== currentSessionId)
-                    continue;
-                if ("entry" in data) {
-                    rememberCompletedChildren(data.entry);
-                    replyTracker.recordIncomingMessage(data.entry.from, data.entry.message, data.entry.receivedAt);
-                    if (!consumedInboundIds.has(data.entry.message.id))
-                        keepInbound({ ...data.entry });
-                }
-                else if (data.stage === "reply-retired") {
-                    replyTracker.markReplied(data.messageId);
-                }
-                else if (data.stage === "discarded") {
-                    pendingInbound.delete(data.messageId);
-                    replyTracker.markReplied(data.messageId);
-                }
-                else {
-                    const pending = pendingInbound.get(data.messageId);
-                    if (pending)
-                        pendingInbound.set(data.messageId, { ...pending, stage: data.stage });
-                }
-            }
-            else if (item.type === "custom" && item.customType === "intercom_sent") {
-                const sent = item.data;
-                if (sent?.message?.replyTo)
-                    replyTracker.markReplied(sent.message.replyTo);
-            }
-        }
-        if (!getLiveContext(ctx, generation))
-            return;
-        reconciledLeafId = leafId;
-        for (const entry of pendingInbound.values()) {
-            discardObsoleteProgress(entry);
-        }
-    }
-    async function restoreInbound(ctx, generation) {
-        await runCooperatively(restoreInboundEntries(ctx, generation));
-        if (!getLiveContext(ctx, generation))
-            return;
-        if (replyTracker.hasReplyContext) {
-            const questions = await listSupervisorQuestionsAsync(ctx.sessionManager.getSessionId());
-            if (!getLiveContext(ctx, generation))
-                return;
-            for (const question of questions) {
-                if (question.answer || question.state === "cancelled")
-                    replyTracker.markReplied(question.questionId);
-            }
-        }
-        reconcileConsumedInbound(ctx);
-        reconcileIntercom(ctx);
-    }
-    function sendIncomingMessage(entry, delivery, generation = runtimeGeneration) {
-        if (runtimeStarted && !getLiveContext(runtimeContext, generation)) {
-            return;
-        }
-        if ("stage" in entry && pendingInbound.get(entry.message.id) !== entry)
-            return;
-        if (discardObsoleteProgress(entry))
-            return;
-        rememberInbound(entry, "native", delivery === "passive" ? "passive" : "auto");
-        if (delivery === "steer" || delivery === "followUp")
-            nativePendingIds.add(entry.message.id);
-        if (delivery !== "passive") {
-            replyTracker.queueTurnContext({ from: entry.from, message: entry.message, receivedAt: Date.now() });
-        }
-        if (delivery !== "passive" && needsIntercom(entry))
-            activateTools(pi, ["intercom"]);
-        const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
-        const bodyText = entry.bodyText;
-        const replyInstruction = entry.replyCommand ? `\n\nTo reply, use the intercom tool: ${entry.replyCommand}` : "";
-        const human = entry.message.human !== undefined;
-        const options = delivery === "trigger"
-            ? { triggerTurn: true }
-            : delivery === "followUp" || delivery === "steer"
-                ? { deliverAs: delivery }
-                : { triggerTurn: false };
-        pi.sendMessage({
-            customType: human ? "subagent-human-message" : "intercom_message",
-            content: human
-                ? `Direct user message to this agent (human origin, not peer advice). Respond in this conversation; the user sees it directly. Do not ask the parent to relay or approve it.\n\n${bodyText}`
-                : `**📨 From ${senderDisplay}** (Native session cwd: ${entry.from.cwd})${replyInstruction}\n\n${bodyText}`,
-            display: true,
-            details: { ...entry, bodyText },
-        }, options);
-        if (delivery === "passive" && runtimeContext)
-            reconcileConsumedInbound(runtimeContext);
-    }
-    function isBlockingSubagentSupervisorMessage(entry) {
-        if (!entry.message.expectsReply)
-            return false;
-        const text = entry.bodyText.trimStart();
-        return text.startsWith("Subagent needs a supervisor decision.")
-            || text.startsWith("Subagent requests a structured supervisor interview.");
-    }
-    async function requestSubagentDetachForBlockingSupervisorMessage(entry, attention = false) {
-        if (!attention && !isBlockingSubagentSupervisorMessage(entry))
-            return false;
-        const requestId = randomUUID();
-        return await new Promise((resolve) => {
-            let settled = false;
-            let unsubscribe;
-            const finish = (accepted) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                unsubscribe?.();
-                resolve(accepted);
-            };
-            const timer = setTimeout(() => finish(false), INTERCOM_DETACH_RESPONSE_TIMEOUT_MS);
-            timer.unref?.();
-            unsubscribe = pi.events.on(INTERCOM_DETACH_RESPONSE_EVENT, (payload) => {
-                if (!payload || typeof payload !== "object")
-                    return;
-                const response = payload;
-                if (response.requestId !== requestId)
-                    return;
-                finish(response.accepted === true);
-            });
-            try {
-                pi.events.emit(INTERCOM_DETACH_REQUEST_EVENT, { requestId, ...(attention ? { reason: "attention" } : {}) });
-                // Owned waits answer ordinary attention synchronously, so an unanswered probe can finish now.
-                if (attention)
-                    finish(false);
-            }
-            catch {
-                finish(false);
-            }
-        });
-    }
-    function scheduleInboundFlush(delayMs = INBOUND_FLUSH_DELAY_MS) {
-        if (!getLiveContext()) {
-            return;
-        }
-        const scheduledGeneration = runtimeGeneration;
-        clearInboundFlushTimer();
-        inboundFlushTimer = setTimeout(() => {
-            inboundFlushTimer = null;
-            void flushIdleMessages(scheduledGeneration)?.catch((error) => console.error("Intercom inbound delivery failed:", error));
-        }, delayMs);
-        inboundFlushTimer.unref?.();
-    }
-    function flushIdleMessages(generation = runtimeGeneration) {
-        if (inboundBatch)
-            return inboundBatch;
-        const entries = queuedInbound();
-        if (entries.length === 0)
-            return;
-        const ctx = getLiveContext(runtimeContext, generation);
-        if (!ctx)
-            return;
-        if (!isRecipientIdle(ctx)) {
-            const steers = entries.filter((entry) => entry.flushDelivery === "steer"
-                && (requestedDelivery(entry.message) === "steer" || !ctx.hasUI && activeTools.size === 0));
-            if (!steers.length) {
-                scheduleInboundFlush(INBOUND_IDLE_RETRY_MS);
-                return;
-            }
-            return runInboundBatch(async () => {
-                const detachments = [];
-                await runCooperatively((function* () {
-                    for (const entry of steers) {
-                        if (!getLiveContext(runtimeContext, generation))
-                            return;
-                        if (pendingInbound.get(entry.message.id) !== entry)
-                            continue;
-                        sendIncomingMessage(entry, "steer", generation);
-                        if (requestedDelivery(entry.message) === "steer" && entry.from.id !== "subagent-result" && entry.from.id !== "subagent-control") {
-                            detachments.push(requestSubagentDetachForBlockingSupervisorMessage(entry, !isBlockingSubagentSupervisorMessage(entry)));
-                        }
-                        yield;
-                    }
-                })());
-                await Promise.all(detachments);
-            }, generation);
-        }
-        return runInboundBatch(() => runCooperatively(sendTriggerLast(entries, generation)), generation);
-    }
-    function queueIdleMessage(entry, flushDelivery = "auto", delayMs = INBOUND_FLUSH_DELAY_MS) {
-        rememberInbound(entry, "queued", flushDelivery);
-        syncPresenceStatus();
-        scheduleInboundFlush(delayMs);
-    }
-    function reconcileConsumedInbound(ctx, fullScan = false) {
-        const leafId = ctx.sessionManager.getLeafId();
-        if (pendingInbound.size > 0) {
-            const recent = [];
-            let id = leafId;
-            // Passive appends emit SDK events, not extension message_end. Walk only
-            // new entries; a moved/missing branch boundary still needs full history.
-            while (!fullScan && id !== reconciledLeafId) {
-                const entry = id ? ctx.sessionManager.getEntry(id) : undefined;
-                if (!entry) {
-                    fullScan = true;
-                    break;
-                }
-                recent.push(entry);
-                id = entry.parentId;
-            }
-            for (const metadata of fullScan ? ctx.sessionManager.getEntries() : recent) {
-                if (metadata.type !== "custom_message" || !["intercom_message", "subagent-human-message"].includes(metadata.customType))
-                    continue;
-                const entry = ctx.sessionManager.getEntry(metadata.id) ?? metadata;
-                const inboundId = inboundIdFromCustomMessage(entry);
-                if (inboundId)
-                    consumedInboundIds.add(inboundId);
-            }
-            for (const pendingId of pendingInbound.keys()) {
-                if (consumedInboundIds.has(pendingId)) {
-                    pendingInbound.delete(pendingId);
-                    nativePendingIds.delete(pendingId);
-                }
-            }
-        }
-        reconciledLeafId = leafId;
-    }
-    async function redeliverUnconsumedInbound(ctx, generation) {
-        if (inboundBatch)
-            await inboundBatch;
-        if (!getLiveContext(ctx, generation))
-            return;
-        reconcileConsumedInbound(ctx);
-        // Public coarse occupancy excludes custom queues on Pi 1.0; the existing
-        // turn boundary's occupancy distinguishes retained from fully cleared work.
-        if (pendingInbound.size === 0 || ctx.hasPendingMessages())
-            return;
-        const entries = [...pendingInbound.values()].filter((entry) => entry.stage === "native" && !nativePendingIds.has(entry.message.id));
-        await runInboundBatch(() => runCooperatively(sendTriggerLast(entries, generation)), generation);
-    }
-    function isOwnedHumanMessage(from, message) {
-        const origin = message.human;
-        if (!origin || !childOrchestratorMetadata || origin.runId !== childOrchestratorMetadata.runId || origin.index !== Number(childOrchestratorMetadata.index))
-            return false;
-        const owner = readRunJson(path.join(getRunMetadataDir(origin.runId), "question-owner.json"));
-        return owner?.sessionId === origin.ownerSessionId && from.id === `pi-${createHash("sha256").update(origin.ownerSessionId).digest("hex").slice(0, 32)}`;
-    }
-    async function handleIncomingMessage(ctx, from, message) {
-        const messageGeneration = runtimeGeneration;
-        if (inboundRestore)
-            await inboundRestore;
-        const liveContext = getLiveContext(ctx, messageGeneration);
-        if (!liveContext) {
-            return;
-        }
-        if (topics.receive(from, message))
-            return;
-        if (message.topic)
-            message = { ...message, content: { ...message.content, text: `Topic ${message.topic.topic} · ${message.topic.event}\n${message.content.text}` } };
-        if (replyWaiter) {
-            const senderTarget = from.name || from.id;
-            const fromMatches = senderTarget.toLowerCase() === replyWaiter.from.toLowerCase()
-                || from.id === replyWaiter.from;
-            const replyMatches = message.replyTo === replyWaiter.replyTo;
-            if (fromMatches && replyMatches) {
-                markIntercomActivity();
-                syncPresenceStatus();
-                replyWaiter.resolve(message);
-                return;
-            }
-        }
-        if (message.human && !isOwnedHumanMessage(from, message))
-            message = { ...message, human: undefined };
-        const attachmentText = message.content.attachments?.length
-            ? formatAttachments(message.content.attachments)
-            : "";
-        const bodyText = `${message.content.text}${attachmentText}`;
-        const replyCommand = config.replyHint && message.expectsReply
-            ? `intercom({ action: "reply", message: "..." })`
-            : undefined;
-        replyTracker.recordIncomingMessage(from, message);
-        markIntercomActivity();
-        syncPresenceStatus();
-        const entry = { from, message, replyCommand, bodyText };
-        if (discardObsoleteProgress(entry))
-            return;
-        const activeContext = getLiveContext(liveContext, messageGeneration);
-        if (!activeContext) {
-            return;
-        }
-        const delivery = requestedDelivery(message);
-        if (inboundBatch) {
-            queueIdleMessage(entry, delivery === "passive" ? "passive" : delivery === "steer" ? "steer" : "auto");
-            return;
-        }
-        if (delivery === "queue" && message.queueMode === "replace") {
-            if (!isRecipientIdle(activeContext) && !activeContext.hasUI) {
-                queueIdleMessage(entry, "steer", NON_UI_REPLACE_FLUSH_DELAY_MS);
-                return;
-            }
-            queueIdleMessage(entry, "auto");
-            return;
-        }
-        if (!isRecipientIdle(activeContext)) {
-            if (isBlockingSubagentSupervisorMessage(entry)) {
-                const willDeliver = activeContext.hasUI || delivery !== "auto";
-                if (willDeliver)
-                    rememberInbound(entry, "queued", "auto");
-                await requestSubagentDetachForBlockingSupervisorMessage(entry);
-                if (!getLiveContext(liveContext, messageGeneration) || (willDeliver && pendingInbound.get(message.id)?.stage !== "queued")) {
-                    return;
-                }
-            }
-            if (delivery === "steer") {
-                // Queue first, then release a delegated foreground wait so native Pi can consume the steer.
-                sendIncomingMessage(entry, "steer", messageGeneration);
-                if (!isBlockingSubagentSupervisorMessage(entry))
-                    await requestSubagentDetachForBlockingSupervisorMessage(entry, true);
-                return;
-            }
-            if (delivery === "queue" && message.queueMode !== "replace") {
-                sendIncomingMessage(entry, "followUp", messageGeneration);
-                return;
-            }
-            if (delivery === "passive") {
-                queueIdleMessage(entry, "passive");
-                return;
-            }
-            if (!activeContext.hasUI) {
-                if (!message.expectsReply) {
-                    sendIncomingMessage(entry, "steer", messageGeneration);
-                    return;
-                }
-                const activeClient = client;
-                if (!message.replyTo && activeClient?.isConnected()) {
-                    try {
-                        const result = await activeClient.send(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: message.id,
-                        });
-                        if (result.delivered && getLiveContext(liveContext, messageGeneration)) {
-                            replyTracker.markReplied(message.id);
-                            markIntercomActivity();
-                            syncPresenceStatus();
-                        }
-                    }
-                    catch {
-                        // Best-effort reply; keep the busy non-interactive session running either way.
-                    }
-                }
-                return;
-            }
-            queueIdleMessage(entry, "auto");
-            return;
-        }
-        if (getLiveContext(liveContext, messageGeneration)) {
-            sendIncomingMessage(entry, delivery === "passive" ? "passive" : "trigger", messageGeneration);
-        }
-    }
-    function attachClientHandlers(nextClient) {
-        nextClient.on("message", (from, message) => {
-            const liveContext = getLiveContext();
-            if (client !== nextClient || !liveContext) {
-                return;
-            }
-            void handleIncomingMessage(liveContext, from, message).catch((error) => {
-                console.error("Intercom inbound delivery failed:", error);
-            });
-        });
-        nextClient.on("session_left", (sessionId) => {
-            if (client !== nextClient) {
-                return;
-            }
-            topics.disconnected(sessionId);
-            rejectReplyWaiterForPeer(sessionId);
-            for (const pending of replyTracker.listPending()) {
-                if (pending.from.id === sessionId && !isDurableSupervisorQuestion(pending.message)
-                    && pendingInbound.get(pending.message.id)?.stage !== "queued")
-                    retireReply(pending.message.id);
-            }
-            replyTracker.expireSender(sessionId);
-            for (const pending of queuedInbound()) {
-                if (pending.from.id === sessionId && pending.message.expectsReply && !isDurableSupervisorQuestion(pending.message)) {
-                    pendingInbound.delete(pending.message.id);
-                    checkpointInbound({ messageId: pending.message.id, stage: "discarded" });
-                }
-            }
-        });
-        nextClient.on("disconnected", (error) => {
-            if (client !== nextClient) {
-                return;
-            }
-            if (!replyWaiter?.question)
-                rejectReplyWaiter(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
-            client = null;
-            topics.disconnected();
-            if (!disposed) {
-                clearReconnectTimer();
-                scheduleReconnect();
-            }
-        });
-        nextClient.on("error", () => {
-            // Keep broker/socket noise out of the TUI. Reconnect logic runs from the disconnect path.
-        });
-    }
-    function scheduleReconnect() {
-        if (disposed || reconnectTimer || reconnectPromise || !getLiveContext()) {
-            return;
-        }
-        const scheduledGeneration = runtimeGeneration;
-        reconnectTimer = setTimeout(() => {
-            reconnectTimer = null;
-            if (scheduledGeneration !== runtimeGeneration || !getLiveContext()) {
-                return;
-            }
-            reconnectAttempt += 1;
-            void ensureConnected("background").catch(() => {
-                // ensureConnected("background") already queued the next retry.
-            });
-        }, getReconnectDelayMs());
-        reconnectTimer.unref?.();
-    }
-    async function restoreTopics(activeClient) {
-        const changes = [
-            ...[...topics.published.values()].map((topic) => ({ action: "restore", topic })),
-            ...[...topics.subscriptions.values()].map((subscription) => ({ action: "restore", subscription })),
-        ];
-        let failure;
-        for (const change of changes) {
-            try {
-                await activeClient.updateTopics(change);
-            }
-            catch (error) {
-                if (!activeClient.isConnected())
-                    throw error;
-                failure ??= getErrorMessage(error);
-            }
-        }
-        return failure;
-    }
-    async function ensureConnected(reason) {
-        const generationAtStart = runtimeGeneration;
-        if (inboundRestore)
-            await inboundRestore;
-        if (disposed || generationAtStart !== runtimeGeneration) {
-            throw new Error("Intercom shutting down");
-        }
-        if (reconnectPromise && reconnectPromiseGeneration === runtimeGeneration)
-            return reconnectPromise;
-        if (client && client.isConnected()) {
-            return client;
-        }
-        const contextAtStart = getLiveContext();
-        if (!contextAtStart || !currentSessionId) {
-            throw new Error("Intercom runtime not initialized");
-        }
-        clearReconnectTimer();
-        if (reconnectPromise && reconnectPromiseGeneration === generationAtStart) {
-            return reconnectPromise;
-        }
-        let nextReconnectPromise;
-        let retryAfterSettle = false;
-        nextReconnectPromise = (async () => {
-            const nextClient = new IntercomClient({ sendTimeoutMs: config.sendTimeoutMs, listTimeoutMs: config.listTimeoutMs });
-            client = nextClient;
-            attachClientHandlers(nextClient);
-            try {
-                if (reason !== "peer-awareness") {
-                    await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
-                }
-                await nextClient.connect(await buildRegistration(), `pi-${createHash("sha256").update(currentSessionId).digest("hex").slice(0, 32)}`);
-                if (!getLiveContext(contextAtStart, generationAtStart)) {
-                    await nextClient.disconnect();
-                    throw new Error("Intercom runtime no longer active");
-                }
-                client = nextClient;
-                // Startup can change the name before registration accepts presence updates.
-                syncPresenceIdentity(contextAtStart.sessionManager.getSessionId());
-                reconnectAttempt = 0;
-                if (nextClient.supportsTopics) {
-                    const failure = await restoreTopics(nextClient);
-                    const sessions = await nextClient.listSessions();
-                    if (getLiveContext(contextAtStart, generationAtStart)) {
-                        topicSyncError = failure;
-                        topics.refresh(sessions);
-                        if (failure)
-                            topics.disconnected(nextClient.sessionId);
-                    }
-                }
-                else
-                    topics.disconnected();
-                return nextClient;
-            }
-            catch (error) {
-                if (client === nextClient) {
-                    client = null;
-                }
-                // Retry intent must not depend on the caller: a foreground tool or
-                // overlay attempt clears any pending reconnect timer on entry, so a
-                // failed attempt that does not re-arm would silently end recovery
-                // (background reasons coalescing behind a foreground promise lose
-                // their reason too). scheduleReconnect() self-guards against
-                // duplicates via the timer, promise, and liveness checks.
-                retryAfterSettle = Boolean(getLiveContext(contextAtStart, generationAtStart));
-                throw toError(error);
-            }
-            finally {
-                if (reconnectPromise === nextReconnectPromise) {
-                    reconnectPromise = null;
-                    reconnectPromiseGeneration = null;
-                }
-                // scheduleReconnect() refuses to schedule while reconnectPromise is
-                // set, so a failed background attempt must queue its next retry only
-                // after the promise slot clears. Scheduling from the catch block ran
-                // before that and silently killed the retry chain on first failure.
-                if (retryAfterSettle) {
-                    scheduleReconnect();
-                }
-            }
-        })();
-        reconnectPromise = nextReconnectPromise;
-        reconnectPromiseGeneration = generationAtStart;
-        return nextReconnectPromise;
-    }
-    async function resolveSessionTarget(activeClient, nameOrId) {
-        const sessions = await activeClient.listSessions();
-        const resolution = resolveSessionTargetValue(sessions, nameOrId);
-        if (resolution.status === "found") {
-            return resolution.target.id;
-        }
-        if (resolution.status === "ambiguous") {
-            throw new Error(`Target "${nameOrId}" matches multiple sessions. Use one of these targets: ${formatTargetOptions(resolution.matches, sessions)}.`);
-        }
-        if (resolution.status === "prefix_too_short") {
-            throw new Error(`Target "${nameOrId}" is too short. Use the displayed target from intercom list, such as ${formatTargetOptions(resolution.matches, sessions)}.`);
-        }
-        return null;
-    }
-    /** Look up a connected peer's latest published health by session id. Returns null if unavailable. */
-    async function resolvePeerHealth(activeClient, sessionId) {
-        try {
-            const sessions = await activeClient.listSessions();
-            return sessions.find((session) => session.id === sessionId) ?? null;
-        }
-        catch {
-            // If health cannot be resolved, callers keep the normal reply wait.
-            return null;
-        }
-    }
-    /** Only an explicit refusal skips the default reply wait. */
-    function peerDeclinesAsks(health) {
-        return health?.acceptsAsks === false;
-    }
-    function deliverLocalSubagentRelayMessage(sender, status, messageText, completion) {
-        const now = Date.now();
-        const entry = {
-            from: {
-                id: sender,
-                name: sender,
-                cwd: runtimeContext?.cwd ?? process.cwd(),
-                model: sender,
-                status,
-            },
-            message: {
-                id: completion?.completionId ? `subagent-completion:${completion.completionId}` : randomUUID(),
-                timestamp: now,
-                content: { text: messageText },
-            },
-            bodyText: messageText,
-            ...(sender === "subagent-result" && completion && currentSessionId ? { subagentCompletion: { ...completion, ownerSessionId: currentSessionId } } : {}),
-        };
-        if (consumedInboundIds.has(entry.message.id) || pendingInbound.has(entry.message.id))
-            return;
-        rememberCompletedChildren(entry);
-        if (inboundBatch)
-            queueIdleMessage(entry, "steer");
-        else
-            sendIncomingMessage(entry, "trigger");
-    }
-    function recordSubagentDeliveryError(entryType, to, message, error) {
-        pi.appendEntry(entryType, {
-            to,
-            message,
-            error: getErrorMessage(error),
-            timestamp: Date.now(),
-        });
-    }
-    function emitResultDelivery(requestId, delivered, error) {
-        if (!requestId)
-            return;
-        pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
-            requestId,
-            delivered,
-            ...(error ? { error: getErrorMessage(error) } : {}),
-        });
-    }
-    async function relaySubagentIntercomPayload(payload, options) {
-        const parsed = parseSubagentIntercomPayload(payload);
-        if (!parsed)
-            return;
-        const relayGeneration = runtimeGeneration;
-        const relayStillLive = () => !runtimeStarted || Boolean(getLiveContext(runtimeContext, relayGeneration));
-        try {
-            if (inboundRestore)
-                await inboundRestore;
-            if (!relayStillLive())
-                return;
-            if (!currentSessionTargetMatches(parsed.to)) {
-                const activeClient = await ensureConnected("background");
-                const target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
-                if (!relayStillLive())
-                    return;
-                if (!currentSessionTargetMatches(parsed.to, target, activeClient)) {
-                    const result = await activeClient.send(target, { text: parsed.message });
-                    if (!relayStillLive())
-                        return;
-                    if (!result.accepted)
-                        throw new Error(result.reason ?? "Session may not exist or has disconnected.");
-                    if (options.acknowledge)
-                        emitResultDelivery(parsed.requestId, true);
-                    return;
-                }
-            }
-            if (!(options.sender === "subagent-control" && (parsed.source === "foreground" || parsed.source === "async"))) {
-                deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, parsed.completion);
-            }
-            if (options.acknowledge)
-                emitResultDelivery(parsed.requestId, true);
-        }
-        catch (error) {
-            if (!relayStillLive())
-                return;
-            recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
-            if (options.acknowledge)
-                emitResultDelivery(parsed.requestId, false, error);
-        }
-    }
-    // Subagent event bridges (live/health/control/result) are torn down on session_shutdown.
-    // Re-register them on session_start so they survive an in-process restart; the guard skips
-    // the first start (already registered at load) and only restores after a shutdown cleared them.
-    function registerSubagentEventBridges() {
-        return [
-            ...registerSubagentLiveEventHandlers({
-                events: pi.events,
-                ensureConnected: () => ensureConnected("background"),
-                getConnection: () => ({ client, connecting: Boolean(startupConnectTimer || reconnectPromise), started: runtimeStarted }),
-                resolveSessionTarget,
-                currentSessionTargetMatches,
-                getLivenessCheck: () => {
-                    const generation = runtimeGeneration;
-                    return () => !runtimeStarted || Boolean(getLiveContext(runtimeContext, generation));
-                },
-            }),
-            pi.events.on(SUBAGENT_SUPERVISOR_QUESTION_RESOLVED_EVENT, (payload) => {
-                const questionId = payload && typeof payload === "object" ? payload.questionId : undefined;
-                if (typeof questionId !== "string")
-                    return;
-                retireReply(questionId, pendingInbound.delete(questionId) ? "discarded" : "reply-retired");
-                syncPresenceStatus();
-            }),
-            pi.events.on("intercom:open", () => {
-                const ctx = getLiveContext();
-                if (ctx?.mode === "tui")
-                    return openIntercomOverlay(ctx, "all");
-            }),
-            pi.events.on(SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT, (payload) => {
-                const requestId = payload && typeof payload === "object" ? payload.requestId : undefined;
-                if (typeof requestId === "string" && client?.isConnected() && client.sessionId) {
-                    pi.events.emit(SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT, { requestId, sessionId: client.sessionId });
-                }
-            }),
-            pi.events.on(SUBAGENT_CONTROL_INTERCOM_EVENT, (payload) => {
-                return relaySubagentIntercomPayload(payload, {
-                    sender: "subagent-control",
-                    status: "needs_attention",
-                    errorEntryType: "intercom_control_error",
-                });
-            }),
-            pi.events.on(SUBAGENT_RESULT_INTERCOM_EVENT, (payload) => {
-                return relaySubagentIntercomPayload(payload, {
-                    sender: "subagent-result",
-                    status: "result",
-                    errorEntryType: "intercom_result_error",
-                    acknowledge: true,
-                });
-            }),
-        ];
-    }
-    let eventUnsubscribes = registerSubagentEventBridges();
-    let eventBridgesActive = true;
-    pi.on("session_start", async (event, ctx) => {
-        if (!eventBridgesActive) {
-            eventUnsubscribes = registerSubagentEventBridges();
-            eventBridgesActive = true;
-        }
-        disposed = false;
-        runtimeStarted = true;
-        runtimeGeneration += 1;
-        const generation = runtimeGeneration;
-        // A session boundary starts from a cold prompt cache, so re-detect peers
-        // instead of carrying a pin from a previous session in this process.
-        peerAwarenessHintPinned = false;
-        reconnectAttempt = 0;
-        clearReconnectTimer();
-        clearStartupConnectTimer();
-        runtimeContext = ctx;
-        currentSessionId = ctx.sessionManager.getSessionId();
-        topics.start(ctx);
-        topicSyncError = undefined;
-        currentModel = ctx.model?.id ?? "unknown";
-        agentRunning = false;
-        lastIntercomActivity = 0;
-        activeTools.clear();
-        pendingInbound.clear();
-        nativePendingIds.clear();
-        replyTracker.reset();
-        if (event.reason !== "reload")
-            restoreLazyTools(pi, ctx, "load_intercom", ["intercom"]);
-        const restoration = Promise.resolve().then(() => restoreInbound(ctx, generation));
-        inboundRestore = restoration;
-        await restoration;
-        if (!getLiveContext(ctx, generation))
-            return;
-        if (inboundRestore === restoration)
-            inboundRestore = undefined;
-        if (event.reason === "reload") {
-            for (const entry of pendingInbound.values())
-                if (entry.stage === "native")
-                    nativePendingIds.add(entry.message.id);
-        }
-        // A fresh runtime has no inherited native queues. Reload keeps those queues
-        // and in-flight prompts, so only its intercom-staged entries are flushed here.
-        if (event.reason !== "reload" && !ctx.signal && !ctx.hasPendingMessages()) {
-            for (const entry of [...pendingInbound.values()])
-                setInboundStage(entry, "queued");
-        }
-        scheduleStartupConnection(ctx, generation);
-        if (queuedInbound().length > 0)
-            scheduleInboundFlush();
-    });
-    pi.on("session_shutdown", async () => {
-        for (const unsubscribe of eventUnsubscribes) {
-            try {
-                unsubscribe();
-            }
-            catch {
-                // Best effort cleanup for reload/session replacement.
-            }
-        }
-        eventUnsubscribes = [];
-        eventBridgesActive = false;
-        clearStartupConnectTimer();
-        clearReconnectTimer();
-        clearInboundFlushTimer();
-        rejectReplyWaiter(new Error("Session shutting down"));
-        // Native reload keeps this runner valid until shutdown completes. Finish the
-        // owned handoff before invalidating it so cleared native messages cannot strand.
-        await Promise.allSettled([inboundRestore, inboundBatch]);
-        disposed = true;
-        runtimeGeneration += 1;
-        // ponytail: joins the bounded attempt only; overdue custom launchers need lifecycle ownership in broker/spawn.ts.
-        await Promise.allSettled([reconnectPromise]);
-        inboundRestore = undefined;
-        inboundBatch = undefined;
-        replyTracker.reset();
-        pendingInbound.clear();
-        nativePendingIds.clear();
-        consumedInboundIds.clear();
-        completedChildren.clear();
-        reconciledLeafId = null;
-        clearInboundFlushTimer();
-        agentRunning = false;
-        activeTools.clear();
-        if (client) {
-            await client.disconnect();
-            client = null;
-        }
-        runtimeContext = null;
-        currentSessionId = null;
-    });
-    pi.on("session_info_changed", (_event, ctx) => {
-        if (getLiveContext(ctx) && currentSessionId)
-            syncPresenceIdentity(currentSessionId);
-    });
-    pi.on("session_tree", (_event, ctx) => {
-        if (getLiveContext(ctx))
-            reconcileConsumedInbound(ctx, true);
-        reconcileIntercom(ctx);
-    });
-    pi.on("session_compact", (_event, ctx) => reconcileIntercom(ctx));
-    pi.on("turn_end", (event) => {
-        if (!getLiveContext()) {
-            return;
-        }
-        // Pi exposes the next queued batch, not every custom queue item. Empty
-        // proves both queues cleared; a nonempty batch must retain all admitted IDs.
-        // ponytail: selective removal while other items remain is not observable;
-        // use a complete public queue snapshot if the host adds one.
-        if (event.context.pendingMessages.length === 0)
-            nativePendingIds.clear();
-        replyTracker.endTurn();
-        scheduleInboundFlush(0);
-    });
-    pi.on("message_end", (event) => {
-        const message = event.message;
-        const inboundId = inboundIdFromCustomMessage(message);
-        if (inboundId) {
-            consumedInboundIds.add(inboundId);
-            pendingInbound.delete(inboundId);
-            nativePendingIds.delete(inboundId);
-        }
-        const activeClient = client;
-        const context = replyTracker.currentTurn();
-        const errorMessage = getAssistantErrorMessage(message);
-        if (!activeClient?.isConnected() || !context?.message.expectsReply || !errorMessage) {
-            return;
-        }
-        const replyTo = context.message.id;
-        return activeClient.send(context.from.id, {
-            text: `${RECIPIENT_TURN_FAILED_PREFIX} ${errorMessage}`,
-            replyTo,
-            attachments: [{
-                    type: "context",
-                    name: RECIPIENT_TURN_FAILED_ATTACHMENT,
-                    content: errorMessage,
-                }],
-        }).then((result) => {
-            if (result.delivered && !isDurableSupervisorQuestion(context.message)) {
-                retireReply(replyTo);
-            }
-        }).catch(() => {
-            // Best-effort failure propagation; the local error remains visible in the recipient session.
-        });
-    });
-    pi.on("agent_start", () => {
-        if (!getLiveContext()) {
-            return;
-        }
-        agentRunning = true;
-        activeTools.clear();
-        syncPresenceStatus();
-        return flushIdleMessages();
-    });
-    pi.on("tool_execution_start", (event) => {
-        if (!getLiveContext()) {
-            return;
-        }
-        activeTools.set(event.toolCallId, event.toolName);
-        syncPresenceStatus();
-    });
-    pi.on("tool_execution_end", (event) => {
-        if (!getLiveContext()) {
-            return;
-        }
-        activeTools.delete(event.toolCallId);
-        syncPresenceStatus();
-        return flushIdleMessages();
-    });
-    pi.on("agent_settled", async (_event, ctx) => {
-        // A rejected concurrent prompt may settle while the original run is active.
-        if (!getLiveContext(ctx) || ctx.signal) {
-            return;
-        }
-        const generation = runtimeGeneration;
-        agentRunning = false;
-        activeTools.clear();
-        replyTracker.endAgent();
-        syncPresenceStatus();
-        await redeliverUnconsumedInbound(ctx, generation);
-        if (getLiveContext(ctx, generation))
-            scheduleInboundFlush(0);
-    });
-    pi.on("turn_start", (_event, ctx) => {
-        if (!getLiveContext(ctx)) {
-            return;
-        }
-        currentSessionId = ctx.sessionManager.getSessionId();
-        syncPresenceIdentity(ctx.sessionManager.getSessionId());
-        replyTracker.beginTurn();
-    });
-    pi.on("model_select", (event, ctx) => {
-        if (!getLiveContext(ctx)) {
-            return;
-        }
-        currentModel = event.model.id;
-        if (client) {
-            client.updatePresence({
-                ...buildPresenceIdentity(pi, ctx.sessionManager.getSessionId()),
-                model: event.model.id,
-                status: currentStatus(),
-            });
-        }
-    });
-    pi.on("before_agent_start", async (event, ctx) => {
-        if (childOrchestratorMetadata)
-            return;
-        const generation = runtimeGeneration;
-        if (!getLiveContext(ctx, generation))
-            return;
-        if (peerAwarenessHintPinned) {
-            setPromptSection(event.systemPromptOptions, "intercom_peers", PEER_AWARENESS_HINT);
-            return;
-        }
-        const deadline = Date.now() + PEER_AWARENESS_LIST_TIMEOUT_MS;
-        let activeClient = client?.isConnected() ? client : null;
-        if (!activeClient) {
-            clearStartupConnectTimer();
-            const brokerAvailable = await settleWithin(() => isBrokerRunning(), PEER_AWARENESS_LIST_TIMEOUT_MS);
-            const connectBudgetMs = deadline - Date.now();
-            if (brokerAvailable && connectBudgetMs > 0) {
-                activeClient = await settleWithin(() => ensureConnected("peer-awareness"), connectBudgetMs);
-            }
-            if (!activeClient) {
-                if (getLiveContext(ctx, generation))
-                    scheduleStartupConnection(ctx, generation);
-                return;
-            }
-        }
-        const currentBrokerSessionId = activeClient.sessionId;
-        const remainingMs = deadline - Date.now();
-        if (!currentBrokerSessionId || remainingMs <= 0 || !getLiveContext(ctx, generation))
-            return;
-        const sessions = await settleWithin(() => activeClient.listSessions(), remainingMs);
-        if (!sessions || client !== activeClient || !getLiveContext(ctx, generation))
-            return;
-        const hint = formatPeerAwarenessHint(sessions, currentBrokerSessionId);
-        if (!hint)
-            return;
-        peerAwarenessHintPinned = true;
-        setPromptSection(event.systemPromptOptions, "intercom_peers", hint);
-    });
-    pi.registerMessageRenderer("subagent-human-message", (message, _options, theme) => {
-        const details = message.details;
-        return new Text(`${theme.fg("accent", theme.bold("User → this agent"))}\n${details?.bodyText ?? message.content}`, 0, 0);
-    });
-    const messageExpansion = new WeakMap();
-    pi.registerMessageRenderer("intercom_message", (message, options, theme) => {
-        const details = message.details;
-        if (!details)
-            return undefined;
-        const compact = "compactView" in options && options.compactView === true;
-        const attention = details.from.id === "subagent-control" || details.from.status === "needs_attention" || details.message.expectsReply === true || Boolean(details.replyCommand);
-        const renderContent = (expanded) => {
-            if (compact && !expanded && !attention) {
-                const sender = details.from.name || details.from.id.slice(0, 8);
-                const body = details.bodyText || details.message.content.text;
-                const summary = details.subagentCompletion
-                    ? `${details.subagentCompletion.status} [${details.subagentCompletion.runId.slice(0, 8)}]`
-                    : details.from.id === "subagent-result"
-                        ? body.split("\n").slice(2, 6).join(" · ")
-                        : body.split("\n").find((line) => line.trim()) || "(no text)";
-                const preview = `${sender}: ${summary}`.replace(/\s+/g, " ").trim();
-                let cachedWidth;
-                let cachedKey;
-                let cachedLines;
-                return {
-                    render(width) {
-                        const key = keyText("app.tools.expand");
-                        if (cachedLines && cachedWidth === width && cachedKey === key)
-                            return cachedLines;
-                        const hint = key ? theme.fg("dim", ` · ${key}`) : "";
-                        const text = `${" ".repeat(options.outputPad)}${theme.fg("accent", "📨 ")}${theme.fg("muted", preview)}`;
-                        cachedWidth = width;
-                        cachedKey = key;
-                        cachedLines = [truncateToWidth(truncateToWidth(text, width - visibleWidth(hint)) + hint, width)];
-                        return cachedLines;
-                    },
-                    invalidate() { cachedLines = undefined; },
-                };
-            }
-            return new InlineMessageComponent(details.from, details.message, theme, details.replyCommand, details.bodyText, expanded || details.from.id !== "subagent-result" || attention);
-        };
-        if (attention || (!compact && details.from.id !== "subagent-result"))
-            return renderContent(options.expanded);
-        let state = messageExpansion.get(message);
-        if (!state || state.globalExpanded !== options.expanded) {
-            state = { expanded: options.expanded, globalExpanded: options.expanded };
-            messageExpansion.set(message, state);
-        }
-        const expansion = state;
-        let component = renderContent(expansion.expanded);
-        return new MouseRegion({ render: (width) => component.render(width), invalidate: () => component.invalidate() }, (event) => {
-            if (event.type !== "click" || event.button !== "left")
-                return;
-            expansion.expanded = !expansion.expanded;
-            component = renderContent(expansion.expanded);
-            return { handled: true };
-        });
-    });
-    async function requestSupervisorDecision(reason, message, interview, signal, ctx) {
-        if (replyWaiter)
-            throw new Error("Already waiting for a reply");
-        if (signal?.aborted)
-            throw new Error("Cancelled");
-        const metadata = childOrchestratorMetadata;
-        const body = interview ? formatSupervisorInterviewRequest(interview, message) : message;
-        const question = createSupervisorQuestion({
-            runId: metadata.runId,
-            ownerTarget: metadata.orchestratorTarget,
-            agent: metadata.agent,
-            index: Number(metadata.index),
-            childSessionId: ctx.sessionManager.getSessionId(),
-            childTarget: metadata.sessionName ?? buildPresenceIdentity(pi, ctx.sessionManager.getSessionId()).name,
-            sessionFile: ctx.sessionManager.getSessionFile() ?? "",
-            cwd: ctx.cwd,
-            pid: process.pid,
-            reason,
-            message: body,
-            ...(interview ? { interview } : {}),
-        });
-        const requestText = formatChildOrchestratorMessage(interview ? "interview" : "ask", metadata, [
-            `Question ID: ${question.questionId}`,
-            `Answer after reconnect/reload: ${formatRunAction("answer", question.runId, { questionId: question.questionId, message: "..." }, Number(process.env.PI_SUBAGENT_DEPTH) > 1)}`,
-            body,
-        ].join("\n"));
-        const replyPromise = waitForReply(metadata.orchestratorTarget, question.questionId, signal, question);
-        // Persistence is the delivery path; intercom only wakes the supervisor. Going offline does not end the wait.
-        let retryAfter = 0;
-        let notificationFailureLogged = false;
-        const notifySupervisor = async () => {
-            const waiter = currentReplyWaiter();
-            if (waiter?.replyTo !== question.questionId || Date.now() < retryAfter)
-                return;
-            waiter.retryNotification = undefined;
-            let retry = true;
-            try {
-                const connectedClient = await ensureConnected("tool");
-                if (currentReplyWaiter() !== waiter)
-                    return;
-                const to = await resolveSessionTarget(connectedClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
-                if (currentReplyWaiter() !== waiter)
-                    return;
-                waiter.from = to;
-                // Once dispatched, an exception may mean a lost acknowledgement. Only explicit rejection is safe to replay.
-                retry = false;
-                const sent = await connectedClient.send(to, { text: requestText, messageId: question.questionId, expectsReply: true, delivery: "steer" });
-                if (currentReplyWaiter() !== waiter)
-                    return;
-                retry = !sent.accepted;
-                if (sent.accepted || !notificationFailureLogged) {
-                    pi.appendEntry("intercom_sent", { to, messageId: question.questionId, message: { text: requestText, reason }, accepted: sent.accepted, timestamp: Date.now() });
-                }
-                notificationFailureLogged ||= !sent.accepted;
-            }
-            catch (error) {
-                if (currentReplyWaiter() === waiter && !notificationFailureLogged) {
-                    pi.appendEntry("intercom_question_notification_error", { questionId: question.questionId, error: getErrorMessage(error) });
-                    notificationFailureLogged = true;
-                }
-            }
-            finally {
-                if (retry && currentReplyWaiter() === waiter) {
-                    retryAfter = Date.now() + 1000;
-                    waiter.retryNotification = () => { void notifySupervisor(); };
-                }
-            }
-        };
-        void notifySupervisor();
-        const replyMessage = await replyPromise;
-        const replyText = replyMessage.content.text;
-        const replyAttachments = replyMessage.content.attachments?.length ? formatAttachments(replyMessage.content.attachments) : "";
-        const structuredReply = interview ? parseStructuredSupervisorReply(replyText, interview) : undefined;
-        pi.appendEntry("intercom_received", { from: metadata.orchestratorTarget, questionId: question.questionId, message: { text: replyText, attachments: replyMessage.content.attachments }, messageId: replyMessage.id, timestamp: replyMessage.timestamp });
-        recordQuestionDelivery(question, { kind: "live", runId: question.runId, deliveredAt: Date.now() });
-        return {
-            content: [{ type: "text", text: `**${readQuestionState(question).answer?.origin === "human" ? "Direct user answer (human origin)" : "Reply from supervisor"}:**\n${replyText}${replyAttachments}` }],
-            isError: false,
-            details: { questionId: question.questionId, ...(structuredReply?.value ? { structuredReply: structuredReply.value } : structuredReply?.error ? { structuredReplyParseError: structuredReply.error } : {}) },
-        };
-    }
-    if (childOrchestratorMetadata) {
-        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: Type.Object({
-                reason: StringEnum(["need_decision", "progress_update", "interview_request"], {
-                    description: "Contact reason: 'need_decision' and 'interview_request' steer the supervisor and wait for a reply; 'progress_update' steers a material discovery without waiting for a reply",
-                }),
-                message: Type.Optional(Type.String({
-                    description: "Decision request, optional interview note, or meaningful progress update for the supervisor",
-                })),
-                interview: Type.Optional(Type.Object({
-                    title: Type.Optional(Type.String()),
-                    description: Type.Optional(Type.String()),
-                    questions: Type.Array(Type.Object({
-                        id: Type.String(),
-                        type: StringEnum(["single", "multi", "text", "image", "info"], { description: "Question type: single, multi, text, image, or info" }),
-                        question: Type.String(),
-                        options: Type.Optional(Type.Array(Type.Any())),
-                        context: Type.Optional(Type.String()),
-                    })),
-                }, { description: "Structured interview request for reason='interview_request'" })),
-            }),
-            async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-                return throwIfToolError(await (async () => {
-                    const reason = params.reason;
-                    if (reason !== "need_decision" && reason !== "progress_update" && reason !== "interview_request") {
-                        return {
-                            content: [{ type: "text", text: "Invalid reason. Use 'need_decision', 'interview_request', or 'progress_update'." }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    if ((reason === "need_decision" || reason === "progress_update") && typeof params.message !== "string") {
-                        return {
-                            content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    const interviewValidation = reason === "interview_request"
-                        ? validateSupervisorInterviewRequest(params.interview)
-                        : undefined;
-                    if (interviewValidation?.ok === false) {
-                        return {
-                            content: [{ type: "text", text: `Invalid interview request: ${interviewValidation.error}` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    const supervisorInterview = interviewValidation?.ok === true ? interviewValidation.interview : undefined;
-                    if (reason !== "progress_update") {
-                        return await requestSupervisorDecision(reason, params.message, supervisorInterview, signal, ctx);
-                    }
-                    let connectedClient;
-                    try {
-                        connectedClient = await ensureConnected("tool");
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    syncPresenceIdentity(ctx.sessionManager.getSessionId());
-                    if (signal?.aborted) {
-                        return {
-                            content: [{ type: "text", text: "Cancelled" }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    const metadata = childOrchestratorMetadata;
-                    let sendTo;
-                    try {
-                        sendTo = await resolveSessionTarget(connectedClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Failed to resolve supervisor target: ${getErrorMessage(error)}` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    if (signal?.aborted) {
-                        return {
-                            content: [{ type: "text", text: "Cancelled" }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    if (sendTo === connectedClient.sessionId) {
-                        return {
-                            content: [{ type: "text", text: "Cannot message the current session" }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                    const message = params.message;
-                    try {
-                        const result = await connectedClient.send(sendTo, {
-                            text: formatChildOrchestratorMessage("update", metadata, message),
-                            delivery: "steer",
-                        });
-                        if (!result.accepted) {
-                            const errorText = result.reason ?? "Session may not exist or has disconnected.";
-                            return {
-                                content: [{ type: "text", text: `Message to "${metadata.orchestratorTarget}" was not delivered: ${errorText}` }],
-                                isError: true,
-                                details: { messageId: result.id, accepted: result.accepted, delivered: false, reason: result.reason },
-                            };
-                        }
-                        markIntercomActivity();
-                        syncPresenceStatus();
-                        pi.appendEntry("intercom_sent", {
-                            to: metadata.orchestratorTarget,
-                            message: { text: message, reason },
-                            messageId: result.id,
-                            timestamp: Date.now(),
-                            subagent: { runId: metadata.runId, agent: metadata.agent, index: metadata.index },
-                        });
-                        return {
-                            content: [{ type: "text", text: `Progress update accepted for supervisor ${metadata.orchestratorTarget}. Queued for the next tool boundary; broker acceptance does not confirm the supervisor has read or acted on it.` }],
-                            isError: false,
-                            details: { messageId: result.id, accepted: result.accepted, delivered: result.delivered, queued: result.queued === true },
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Failed to send progress update: ${getErrorMessage(error)}` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                    }
-                })());
-            },
-            renderCall(args, theme) {
-                const reason = typeof args.reason === "string" ? args.reason : "contact";
-                const messagePreview = previewText(args.message, 96);
-                const interview = args.interview && typeof args.interview === "object" ? args.interview : undefined;
-                let text = theme.fg("toolTitle", theme.bold("contact_supervisor "));
-                text += theme.fg(reason === "need_decision" ? "warning" : reason === "progress_update" ? "muted" : "accent", reason);
-                if (typeof interview?.title === "string" && interview.title.trim()) {
-                    text += " " + theme.fg("accent", interview.title.trim());
-                }
-                if (messagePreview) {
-                    text += "\n  " + theme.fg("dim", messagePreview);
-                }
-                return new Text(text, 0, 0);
-            },
-            renderResult(result, { isPartial }, theme, context) {
-                if (isPartial) {
-                    return new Text(theme.fg("warning", "Waiting for supervisor..."), 0, 0);
-                }
-                const details = result.details;
-                const textContent = firstTextContent(result);
-                const failed = Boolean(context.isError || details?.error === true || details?.accepted === false);
-                const parseWarning = typeof details?.structuredReplyParseError === "string";
-                let text = failed
-                    ? theme.fg("error", "✗ ")
-                    : parseWarning
-                        ? theme.fg("warning", "⚠ ")
-                        : theme.fg("success", "✓ ");
-                text += theme.fg(failed ? "error" : "text", textContent);
-                if (parseWarning) {
-                    text += "\n" + theme.fg("warning", `Structured reply parse issue: ${details.structuredReplyParseError}`);
-                }
-                return new Text(text, 0, 0);
-            },
-        });
-    }
-    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" && !("namespace" in tool && tool.namespace)))
-                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: {} };
-        },
-    });
-    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.",
-        ],
-        parameters: Type.Object({
-            action: StringEnum(["list", "send", "ask", "reply", "pending", "status", "subscribe", "unsubscribe", "publish", "topics"], {
-                description: "Direct messages: list/send/ask/reply/pending/status. Quiet state: subscribe/unsubscribe/publish/topics.",
-            }),
-            scope: Type.Optional(StringEnum(["project", "all"], {
-                description: "For list/status: 'project' (default) shows this Git repository and its worktrees; 'all' includes sessions in other projects.",
-            })),
-            to: Type.Optional(Type.String({
-                description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
-            })),
-            topic: Type.Optional(Type.String({ description: "Exact opt-in topic for subscribe/unsubscribe/publish/topics; no automatic subscriptions." })),
-            event: Type.Optional(StringEnum(["update", "blocker", "decision", "release"], { description: "Publish: update is quiet current state. Blockers/decisions interrupt subscribers; release interrupts only those awaiting release." })),
-            resource: Type.Optional(Type.String({ description: "Publish: resource this session is using (advisory ownership, not a lock)." })),
-            ownership: Type.Optional(StringEnum(["held", "released"], { description: "Publish: this session's declared resource state. Disconnect never implies released." })),
-            awaitRelease: Type.Optional(Type.Boolean({ description: "Subscribe: interrupt when this topic explicitly releases ownership." })),
-            message: Type.Optional(Type.String({
-                description: "Message for send/ask/reply, or self-contained latest state for publish",
-            })),
-            attachments: Type.Optional(Type.Array(Type.Object({
-                type: StringEnum(["file", "snippet", "context"]),
-                name: Type.String(),
-                content: Type.String(),
-                language: Type.Optional(Type.String()),
-            }))),
-            replyTo: Type.Optional(Type.String({
-                description: "Message ID to reply to (for threading or responding to an 'ask')",
-            })),
-            delivery: Type.Optional(StringEnum(["queue", "steer", "passive"], {
-                description: "Delivery mode. Omitted send delivery defaults to 'steer', which injects after the current tool call. Use 'queue' only to intentionally wait behind active work; 'passive' does not wake the recipient model.",
-            })),
-            queueMode: Type.Optional(StringEnum(["stack", "replace"], {
-                description: "For delivery='queue': 'stack' keeps all messages; 'replace' keeps only the latest undelivered message for the same threadId.",
-            })),
-            threadId: Type.Optional(Type.String({
-                description: "Stable topic key for queueMode='replace'.",
-            })),
-            passive: Type.Optional(Type.Boolean({
-                description: "For action='send' only: legacy alias for delivery='passive'. Discouraged for agent-to-agent messages.",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            return throwIfToolError(await (async () => {
-                let connectedClient;
-                try {
-                    connectedClient = await ensureConnected("tool");
-                }
-                catch (error) {
-                    if (params.action === "topics") {
-                        topics.disconnected();
-                        return { content: [{ type: "text", text: `Broker unavailable; last saved records follow.\n${topics.inspect(params.topic)}` }], details: { connection: "disconnected" } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
-                        isError: true,
-                        details: { error: true },
-                    };
-                }
-                syncPresenceIdentity(ctx.sessionManager.getSessionId());
-                const { action, scope = "project", to, message, attachments, replyTo, delivery, queueMode, threadId, passive } = params;
-                if (["subscribe", "unsubscribe", "publish", "topics"].includes(action)) {
-                    if (!connectedClient.supportsTopics) {
-                        topics.disconnected();
-                        return { content: [{ type: "text", text: `${TOPICS_UNAVAILABLE}${action === "topics" ? `\n\nLast saved records:\n${topics.inspect(params.topic)}` : ""}` }], isError: true, details: { topicsSupported: false } };
-                    }
-                    const generation = runtimeGeneration;
-                    const topic = params.topic?.trim();
-                    if (topic && !isTopicSubscription({ topic, awaitRelease: params.awaitRelease }))
-                        return { content: [{ type: "text", text: "Topic must be a plain nonempty label; awaitRelease must be boolean." }], isError: true, details: {} };
-                    if (action !== "topics" && !topic)
-                        return { content: [{ type: "text", text: `${action} requires an exact topic.` }], isError: true, details: {} };
-                    let change;
-                    if (action === "subscribe")
-                        change = { action: "subscribe", subscription: { topic: topic, ...(params.awaitRelease ? { awaitRelease: true } : {}) } };
-                    if (action === "unsubscribe")
-                        change = { action: "unsubscribe", topic: topic };
-                    if (action === "publish") {
-                        const event = params.event ?? (params.ownership === "released" ? "release" : "update");
-                        const update = { topic: topic, text: message ?? "", event, resource: params.resource, ownership: params.ownership,
-                            revision: (topics.published.get(topic)?.revision ?? 0) + 1, updatedAt: Date.now() };
-                        if (!update.text.trim() || !isTopicUpdate(update) || (event === "release" && (!update.resource || update.ownership !== "released")))
-                            return { content: [{ type: "text", text: "Publish requires self-contained message text; ownership needs resource, and release needs ownership:'released'." }], isError: true, details: {} };
-                        change = { action: "publish", topic: update };
-                    }
-                    const commit = (snapshot) => {
-                        if (!getLiveContext(ctx, generation))
-                            throw new Error("Session changed; no topic state saved in this session.");
-                        if (action === "subscribe")
-                            topics.subscribe(topic, params.awaitRelease);
-                        if (action === "unsubscribe")
-                            topics.unsubscribe(topic);
-                        if (action === "publish") {
-                            const update = snapshot.sessions.find((session) => session.id === connectedClient.sessionId)?.topics?.find((entry) => entry.topic === topic);
-                            if (!update)
-                                throw new Error("Broker did not confirm the topic publication; prior saved state is unchanged.");
-                            topics.publish(update, { id: connectedClient.sessionId, name: pi.getSessionName() });
-                        }
-                        topics.refresh(snapshot.sessions);
-                    };
-                    const snapshot = change ? await connectedClient.updateTopics(change, commit) : { sessions: await connectedClient.listSessions(), receipts: [] };
-                    if (!getLiveContext(ctx, generation))
-                        return { content: [{ type: "text", text: "Session changed; no topic state saved in this session." }], isError: true, details: {} };
-                    if (!change)
-                        topics.refresh(snapshot.sessions);
-                    if (topicSyncError) {
-                        const own = snapshot.sessions.find((session) => session.id === connectedClient.sessionId);
-                        const published = new Map(own?.topics?.map((update) => [update.topic, update]));
-                        const subscribed = new Map(own?.subscriptions?.map((entry) => [entry.topic, entry]));
-                        if (own && published.size === topics.published.size && subscribed.size === topics.subscriptions.size
-                            && [...topics.published].every(([key, update]) => JSON.stringify(published.get(key)) === JSON.stringify(update))
-                            && [...topics.subscriptions].every(([key, entry]) => subscribed.has(key) && Boolean(subscribed.get(key)?.awaitRelease) === Boolean(entry.awaitRelease)))
-                            topicSyncError = undefined;
-                        else
-                            topics.disconnected(connectedClient.sessionId);
-                    }
-                    if (action === "publish") {
-                        const receipts = snapshot.receipts;
-                        return { content: [{ type: "text", text: `Current state saved for ${topic}. ${receipts.filter((receipt) => receipt.accepted).length}/${receipts.length} subscribed deliveries accepted; this does not confirm reading or action. Routine updates stay outside conversation context.` }], details: { topic, receipts } };
-                    }
-                    return { content: [{ type: "text", text: `${topicSyncError ? `Some saved topic state could not be restored: ${topicSyncError}\nOrdinary messaging remains available. Correct the saved publication or subscription.\n\n` : ""}${action === "topics" ? "" : `${action === "subscribe" ? "Subscribed to" : "Unsubscribed from"} ${topic}.\n`}${topics.inspect(topic)}` }], details: { topic } };
-                }
-                if (params.scope !== undefined && action !== "list" && action !== "status") {
-                    return {
-                        content: [{ type: "text", text: "'scope' is only valid for action='list' or action='status'" }],
-                        isError: true,
-                        details: { error: true },
-                    };
-                }
-                if (passive !== undefined && action !== "send") {
-                    return {
-                        content: [{ type: "text", text: "'passive' is only valid for action='send'" }],
-                        isError: true,
-                        details: { error: true },
-                    };
-                }
-                if (delivery === "passive" && action !== "send") {
-                    return {
-                        content: [{ type: "text", text: "delivery='passive' is only valid for action='send'. Passive delivery is for human-visible breadcrumbs and is discouraged for agent-to-agent coordination; normal send defaults to steer. Use ask with delivery='steer' only when the sender must stay alive and cannot safely continue without the reply." }],
-                        isError: true,
-                        details: { error: true },
-                    };
-                }
-                if ((delivery !== undefined || queueMode !== undefined || threadId !== undefined) && action !== "send" && action !== "ask") {
-                    return {
-                        content: [{ type: "text", text: "'delivery', 'queueMode', and 'threadId' are only valid for action='send' or action='ask'" }],
-                        isError: true,
-                        details: failureDetails(queueMode !== undefined || delivery === "queue" || threadId !== undefined ? "invalid_queue_arguments" : "invalid_delivery_arguments", [{ action: "send", guidance: "Use delivery options only with send or ask." }], { error: true }),
-                    };
-                }
-                if (passive === true && delivery !== undefined && delivery !== "passive") {
-                    return {
-                        content: [{ type: "text", text: "'passive' cannot be combined with a non-passive delivery mode" }],
-                        isError: true,
-                        details: { error: true },
-                    };
-                }
-                if (threadId !== undefined && queueMode !== "replace") {
-                    return {
-                        content: [{ type: "text", text: "'threadId' is only valid with queueMode='replace'" }],
-                        isError: true,
-                        details: failureDetails("invalid_queue_arguments", [{ action: "send", guidance: "Use threadId only with delivery='queue' and queueMode='replace'." }], { error: true }),
-                    };
-                }
-                if (queueMode === "replace" && (!threadId || !threadId.trim())) {
-                    return {
-                        content: [{ type: "text", text: "queueMode='replace' requires a non-empty threadId" }],
-                        isError: true,
-                        details: failureDetails("invalid_queue_arguments", [{ action: "send", guidance: "Provide a non-empty threadId with delivery='queue' and queueMode='replace'." }], { error: true }),
-                    };
-                }
-                const deliveryMode = (passive === true ? "passive" : delivery);
-                const cleanedThreadId = typeof threadId === "string" ? threadId.trim() : undefined;
-                if (queueMode !== undefined && deliveryMode !== "queue") {
-                    return {
-                        content: [{ type: "text", text: "'queueMode' is only valid with delivery='queue'. Use queue only for intentionally deferred work; otherwise omit queueMode and use default-steered send for live agent coordination. Avoid passive for agent-to-agent coordination." }],
-                        isError: true,
-                        details: failureDetails("invalid_queue_arguments", [{ action: "send", guidance: "Set delivery='queue', or omit queueMode and threadId." }], { error: true }),
-                    };
-                }
-                switch (action) {
-                    case "list": {
-                        try {
-                            const mySessionId = connectedClient.sessionId;
-                            if (!mySessionId)
-                                throw new Error("Current intercom session id is unavailable.");
-                            const allSessions = await connectedClient.listSessions();
-                            const sessions = sessionsForScope(allSessions, mySessionId, scope);
-                            return {
-                                content: [{ type: "text", text: formatSessionListSections(allSessions, mySessionId, scope) }],
-                                isError: false,
-                                details: { sessionCount: sessions.length },
-                            };
-                        }
-                        catch (error) {
-                            return {
-                                content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                    }
-                    case "send": {
-                        if (!to || !message) {
-                            return {
-                                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                        try {
-                            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
-                            if (sendTo === connectedClient.sessionId) {
-                                return {
-                                    content: [{ type: "text", text: "Cannot message the current session" }],
-                                    isError: true,
-                                    details: { error: true },
-                                };
-                            }
-                            if (!replyTo && config.confirmSend && ctx.hasUI) {
-                                const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
-                                const confirmed = await ctx.ui.confirm("Send Message", `Send to "${to}":\n\n${message}${attachmentText}`);
-                                if (!confirmed) {
-                                    return {
-                                        content: [{ type: "text", text: "Message cancelled by user" }],
-                                        isError: false,
-                                    };
-                                }
-                            }
-                            const result = await connectedClient.send(sendTo, {
-                                text: message,
-                                attachments,
-                                replyTo,
-                                delivery: deliveryMode,
-                                queueMode: queueMode,
-                                threadId: cleanedThreadId,
-                                passive: passive === true,
-                            });
-                            if (!result.accepted) {
-                                const errorText = result.reason ?? "Session may not exist or has disconnected.";
-                                return {
-                                    content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
-                                    isError: true,
-                                    details: failureDetails("delivery_failed", [{ action: "list" }, { action: "send", guidance: "Retry with an exact active recipient target." }], { messageId: result.id, accepted: result.accepted, delivered: false, reason: result.reason }),
-                                };
-                            }
-                            markIntercomActivity();
-                            pi.appendEntry("intercom_sent", {
-                                to,
-                                message: { text: message, attachments, replyTo, delivery: deliveryMode, queueMode, threadId: cleanedThreadId, passive: passive === true },
-                                messageId: result.id,
-                                timestamp: Date.now(),
-                            });
-                            if (replyTo) {
-                                replyTracker.markReplied(replyTo);
-                            }
-                            syncPresenceStatus();
-                            const replyModeHint = replyTo
-                                ? ""
-                                : deliveryMode === "passive"
-                                    ? " (passive; recipient model was not woken)"
-                                    : deliveryMode === "steer"
-                                        ? " (steers active recipient after the current tool call)"
-                                        : deliveryMode === "queue"
-                                            ? " (intentionally deferred behind active recipient work)"
-                                            : " (defaults to steer; wakes idle recipients and steers active recipients after the current tool call)";
-                            return {
-                                content: [{ type: "text", text: result.queued ? `Message queued for ${to} (${result.reason ?? "queued"})` : `Message sent to ${to}${replyModeHint}` }],
-                                isError: false,
-                                details: { messageId: result.id, accepted: result.accepted, delivered: result.delivered, queued: result.queued === true, reasonCode: result.queued ? "message_queued" : "message_accepted" },
-                            };
-                        }
-                        catch (error) {
-                            return {
-                                content: [{ type: "text", text: `Failed to send: ${getErrorMessage(error)}` }],
-                                isError: true,
-                                details: failureDetails(getErrorMessage(error).startsWith("Target ") ? "ambiguous_target" : "send_failed", [{ action: "list" }, { action: "send", guidance: "Retry with an exact active recipient target." }], { error: true }),
-                            };
-                        }
-                    }
-                    case "ask": {
-                        if (!to || !message) {
-                            return {
-                                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                        if (replyWaiter) {
-                            return {
-                                content: [{ type: "text", text: "Already waiting for a reply" }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                        if (_signal?.aborted) {
-                            return {
-                                content: [{ type: "text", text: "Cancelled" }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                        let questionId;
-                        try {
-                            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
-                            if (_signal?.aborted) {
-                                return {
-                                    content: [{ type: "text", text: "Cancelled" }],
-                                    isError: true,
-                                    details: { error: true },
-                                };
-                            }
-                            if (sendTo === connectedClient.sessionId) {
-                                return {
-                                    content: [{ type: "text", text: "Cannot message the current session" }],
-                                    isError: true,
-                                    details: { error: true },
-                                };
-                            }
-                            const peerHealth = await resolvePeerHealth(connectedClient, sendTo);
-                            const skipReplyWait = peerDeclinesAsks(peerHealth) && deliveryMode === undefined;
-                            if (_signal?.aborted) {
-                                return {
-                                    content: [{ type: "text", text: "Cancelled" }],
-                                    isError: true,
-                                    details: { error: true },
-                                };
-                            }
-                            questionId = randomUUID();
-                            const sendOptions = {
-                                text: message,
-                                attachments,
-                                replyTo,
-                                delivery: deliveryMode,
-                                queueMode: queueMode,
-                                threadId: cleanedThreadId,
-                            };
-                            const recordSent = (sendResult) => pi.appendEntry("intercom_sent", {
-                                to,
-                                message: { text: message, attachments, replyTo, delivery: deliveryMode, queueMode, threadId: cleanedThreadId },
-                                messageId: sendResult.id,
-                                timestamp: Date.now(),
-                            });
-                            let replyMessage;
-                            if (skipReplyWait) {
-                                const sendResult = await connectedClient.send(sendTo, { ...sendOptions, messageId: questionId, expectsReply: true });
-                                if (!sendResult.accepted)
-                                    throw new AskDeliveryError(sendResult);
-                                markIntercomActivity();
-                                syncPresenceStatus();
-                                recordSent(sendResult);
-                                return {
-                                    content: [{ type: "text", text: `${sendResult.delivered ? "Delivered" : "Queued"} ask to ${to}; peer is busy and not accepting blocking asks (peer_busy). Not waiting for a reply; delivery does not mean the question was consumed.` }],
-                                    isError: false,
-                                    details: { messageId: sendResult.id, accepted: sendResult.accepted, delivered: sendResult.delivered, queued: sendResult.queued === true, replied: false, reason: "peer_busy", reasonCode: "recipient_not_accepting_asks", nextActions: [{ action: "send", guidance: "Use default-steered send for non-blocking live coordination; queue only when delay is intentional." }] },
-                                };
-                            }
-                            replyMessage = await sendAskTransaction(connectedClient, sendTo, questionId, sendOptions, _signal, recordSent);
-                            const replyText = replyMessage.content.text;
-                            const replyAttachments = replyMessage.content.attachments?.length
-                                ? formatAttachments(replyMessage.content.attachments)
-                                : "";
-                            pi.appendEntry("intercom_received", {
-                                from: to,
-                                message: { text: replyText, attachments: replyMessage.content.attachments },
-                                messageId: replyMessage.id,
-                                timestamp: replyMessage.timestamp,
-                            });
-                            const recipientTurnFailure = replyMessage.content.attachments?.some((attachment) => attachment.name === RECIPIENT_TURN_FAILED_ATTACHMENT);
-                            if (recipientTurnFailure) {
-                                return {
-                                    content: [{ type: "text", text: replyText }],
-                                    isError: true,
-                                    details: failureDetails("recipient_turn_failed", [{ action: "status" }, { action: "send", guidance: "Send recovery context after the recipient is healthy." }], { error: true, recipientTurnFailed: true, messageId: replyMessage.id, replyTo: questionId }),
-                                };
-                            }
-                            return {
-                                content: [{ type: "text", text: `**Reply from ${to}:**\n${replyText}${replyAttachments}` }],
-                                isError: false,
-                            };
-                        }
-                        catch (error) {
-                            if (error instanceof AskDeliveryError) {
-                                return {
-                                    content: [{ type: "text", text: `Message to "${to}" was not delivered: ${error.message}` }],
-                                    isError: true,
-                                    details: failureDetails("delivery_failed", [{ action: "list" }, { action: "send", guidance: "Retry with an exact active recipient target." }], { error: true, messageId: error.result.id, accepted: false, delivered: false, reason: error.result.reason }),
-                                };
-                            }
-                            const errorMessage = getErrorMessage(error);
-                            const timedOut = errorMessage.startsWith("No reply from");
-                            return {
-                                content: [{ type: "text", text: `Failed: ${errorMessage}` }],
-                                isError: true,
-                                details: failureDetails(timedOut ? "reply_timeout" : errorMessage.startsWith("Target ") ? "ambiguous_target" : "ask_failed", [{ action: "status" }, { action: "list" }, { action: "send", guidance: "Check the recipient before retrying; the original ask may still be seen." }], { error: true, ...(questionId ? { messageId: questionId } : {}) }),
-                            };
-                        }
-                    }
-                    case "reply": {
-                        if (!message) {
-                            return {
-                                content: [{ type: "text", text: "Missing 'message' parameter" }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                        try {
-                            const target = replyTracker.resolveReplyTarget({ to, replyTo });
-                            if (target.from.id === connectedClient.sessionId) {
-                                return {
-                                    content: [{ type: "text", text: "Cannot message the current session" }],
-                                    isError: true,
-                                    details: { error: true },
-                                };
-                            }
-                            const result = await connectedClient.send(target.from.id, {
-                                text: message,
-                                attachments,
-                                replyTo: target.message.id,
-                            });
-                            if (!result.accepted) {
-                                const errorText = result.reason ?? "Session may not exist or has disconnected.";
-                                return {
-                                    content: [{ type: "text", text: `Reply to "${target.from.name || target.from.id}" was not delivered: ${errorText}` }],
-                                    isError: true,
-                                    details: failureDetails("delivery_failed", [{ action: "pending" }, { action: "send", guidance: "Send a new message if the original sender is no longer available." }], { messageId: result.id, accepted: result.accepted, delivered: false, queued: result.queued === true, reason: result.reason, replyTo: target.message.id }),
-                                };
-                            }
-                            replyTracker.markReplied(target.message.id);
-                            markIntercomActivity();
-                            syncPresenceStatus();
-                            pi.appendEntry("intercom_sent", {
-                                to: target.from.name || target.from.id,
-                                message: { text: message, replyTo: target.message.id },
-                                messageId: result.id,
-                                timestamp: Date.now(),
-                            });
-                            return {
-                                content: [{ type: "text", text: `Reply sent to ${target.from.name || target.from.id}` }],
-                                isError: false,
-                                details: { messageId: result.id, delivered: true, replyTo: target.message.id, reasonCode: "reply_sent" },
-                            };
-                        }
-                        catch (error) {
-                            const errorMessage = getErrorMessage(error);
-                            const reasonCode = replyFailureReason(errorMessage);
-                            return {
-                                content: [{ type: "text", text: `Failed to reply: ${errorMessage}` }],
-                                isError: true,
-                                details: failureDetails(reasonCode, reasonCode === "no_pending_reply"
-                                    ? [{ action: "pending" }, { action: "send", guidance: "Use send with an explicit recipient when there is no inbound ask to reply to." }]
-                                    : [{ action: "pending" }, { action: "list" }], { error: true, ...(replyTo ? { replyTo } : {}) }),
-                            };
-                        }
-                    }
-                    case "pending": {
-                        const pendingAsks = replyTracker.listPending();
-                        if (pendingAsks.length === 0) {
-                            return {
-                                content: [{ type: "text", text: "No unresolved inbound asks." }],
-                                isError: false,
-                            };
-                        }
-                        const now = Date.now();
-                        const lines = pendingAsks.map(({ from, message, receivedAt }) => {
-                            const preview = pendingAskPreview(message);
-                            const elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1000));
-                            const sender = from.name ? `${from.name} (${formatSessionTarget(from, pendingAsks.map((ask) => ask.from))})` : from.id;
-                            const replyTo = JSON.stringify(message.id);
-                            return `- ${sender} · replyTo: ${replyTo} · ${elapsedSeconds}s ago · ${preview}\n  Reply: intercom({ action: "reply", replyTo: ${replyTo}, message: "..." })`;
-                        });
-                        return {
-                            content: [{ type: "text", text: `**Pending asks:**\n${lines.join("\n")}` }],
-                            isError: false,
-                        };
-                    }
-                    case "status": {
-                        try {
-                            const mySessionId = connectedClient.sessionId;
-                            if (!mySessionId)
-                                throw new Error("Current intercom session id is unavailable.");
-                            const allSessions = await connectedClient.listSessions();
-                            const sessions = sessionsForScope(allSessions, mySessionId, scope);
-                            reconcileConsumedInbound(ctx);
-                            const pending = [...pendingInbound.values()].map((entry) => ({
-                                entry,
-                                state: entry.stage === "queued" ? "queued; not yet delivered to model" : "delivered to model queue; not yet consumed",
-                            }));
-                            const pendingText = pending.length
-                                ? `\n\nPending inbound messages: ${pending.length}\n${pending.map(({ entry, state }) => `- ${entry.from.name || entry.from.id} [${entry.message.id}] (${state})\n${entry.bodyText}`).join("\n\n")}`
-                                : "\n\nPending inbound messages: 0";
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nConnected sessions in scope: ${sessions.length}\n\n${formatSessionListSections(allSessions, mySessionId, scope)}${pendingText}`,
-                                    }],
-                                isError: false,
-                            };
-                        }
-                        catch (error) {
-                            return {
-                                content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
-                                isError: true,
-                                details: { error: true },
-                            };
-                        }
-                    }
-                    default:
-                        return {
-                            content: [{ type: "text", text: `Unknown action: ${action}` }],
-                            isError: true,
-                            details: { error: true },
-                        };
-                }
-            })());
+    const child = readChildOrchestratorMetadata();
+    const lifecycle = new IntercomLifecycle(pi, config);
+    const replies = new ReplyTracker(config.askTimeoutMs);
+    const topics = new IntercomTopics(pi, () => lifecycle.live());
+    const journal = new InboundJournal(pi, lifecycle, replies);
+    const wait = new ReplyWait(pi, lifecycle, config.askTimeoutMs);
+    // Hooks are invoked only after construction, at a native session or event boundary.
+    const connection = new IntercomConnection(lifecycle, config, topics, {
+        restoring: () => delivery.restoring,
+        pendingAsks: () => replies.listPending().length,
+        incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
+        peerLeft: (id) => {
+            wait.peerDisconnected(id);
+            journal.peerLeft(id);
         },
-        renderCall(args, theme) {
-            const action = typeof args.action === "string" ? args.action : "intercom";
-            const target = typeof args.to === "string" && args.to.trim() ? args.to.trim() : undefined;
-            const messagePreview = previewText(args.message, 96);
-            const attachmentCount = Array.isArray(args.attachments) ? args.attachments.length : 0;
-            let text = theme.fg("toolTitle", theme.bold("intercom "));
-            text += theme.fg(action === "ask" ? "warning" : action === "reply" ? "success" : "accent", action);
-            if (target) {
-                text += " " + theme.fg("muted", "→") + " " + theme.fg("accent", target);
+        disconnected: (error) => {
+            if (!wait.durable) {
+                wait.reject(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
             }
-            if (attachmentCount > 0) {
-                text += " " + theme.fg("dim", `(${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"})`);
-            }
-            if (messagePreview) {
-                text += "\n  " + theme.fg("dim", messagePreview);
-            }
-            return new Text(text, 0, 0);
-        },
-        renderResult(result, { expanded, isPartial }, theme, context) {
-            if (isPartial) {
-                return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
-            }
-            const details = result.details;
-            const failed = Boolean(context.isError || details?.error === true || details?.accepted === false);
-            const action = context.args && typeof context.args === "object" && "action" in context.args
-                ? context.args.action
-                : undefined;
-            if (!failed && action === "list" && !expanded) {
-                const summary = details?.sessionCount === undefined
-                    ? "Sessions listed"
-                    : `${details.sessionCount} session${details.sessionCount === 1 ? "" : "s"}`;
-                const key = keyText("app.tools.expand");
-                return new Text(`${theme.fg("success", "✓ ")}${theme.fg("text", summary)}${key ? ` ${theme.fg("dim", `(${key} to expand)`)}` : ""}`, 0, 0);
-            }
-            let text = failed ? theme.fg("error", "✗ ") : theme.fg("success", "✓ ");
-            text += theme.fg(failed ? "error" : "text", firstTextContent(result));
-            if (details?.messageId && !expanded) {
-                text += theme.fg("dim", ` (${details.messageId.slice(0, 8)})`);
-            }
-            if (details?.reason && expanded) {
-                text += "\n" + theme.fg("dim", `Reason: ${details.reason}`);
-            }
-            return new Text(text, 0, 0);
-        },
-    });
-    async function openIntercomOverlay(ctx, scope = "project") {
-        const overlayGeneration = runtimeGeneration;
-        const liveContext = getLiveContext(ctx, overlayGeneration);
-        if (!liveContext?.hasUI)
-            return;
-        let overlayClient;
-        try {
-            overlayClient = await ensureConnected("overlay");
-        }
-        catch (error) {
-            notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
-            return;
-        }
-        if (!getLiveContext(ctx, overlayGeneration))
-            return;
-        syncPresenceIdentity(ctx.sessionManager.getSessionId());
-        let currentSession;
-        let sessions;
-        let allSessions;
-        let hiddenSessionCount = 0;
-        try {
-            const mySessionId = overlayClient.sessionId;
-            if (!mySessionId)
-                throw new Error("Current intercom session id is unavailable.");
-            allSessions = await overlayClient.listSessions();
-            if (!getLiveContext(ctx, overlayGeneration))
-                return;
-            const foundCurrentSession = allSessions.find(s => s.id === mySessionId);
-            if (!foundCurrentSession) {
-                notifyIfLive(ctx, "Current session is missing from intercom session list", "error", overlayGeneration);
-                return;
-            }
-            currentSession = foundCurrentSession;
-            const scopedSessions = sessionsForScope(allSessions, mySessionId, scope);
-            hiddenSessionCount = allSessions.length - scopedSessions.length;
-            sessions = scopedSessions.filter(s => s.id !== mySessionId);
-        }
-        catch (error) {
-            notifyIfLive(ctx, `Failed to list sessions: ${getErrorMessage(error)}`, "error", overlayGeneration);
-            return;
-        }
-        const selectedSession = await ctx.ui.custom((tui, theme, keybindings, done) => new SessionListOverlay(tui, theme, keybindings, currentSession, sessions, done, hiddenSessionCount, allSessions), { overlay: true }).catch(() => undefined);
-        if (!selectedSession || !getLiveContext(ctx, overlayGeneration))
-            return;
-        try {
-            overlayClient = await ensureConnected("overlay");
-        }
-        catch (error) {
-            notifyIfLive(ctx, `Intercom unavailable: ${getErrorMessage(error)}`, "error", overlayGeneration);
-            return;
-        }
-        if (!getLiveContext(ctx, overlayGeneration))
-            return;
-        const targetLabel = targetDisplayName(selectedSession, allSessions);
-        const result = await ctx.ui.custom((tui, theme, keybindings, done) => new ComposeOverlay(tui, theme, keybindings, selectedSession, targetLabel, overlayClient, done), { overlay: true }).catch(() => undefined);
-        if (result?.sent && result.messageId && result.text && getLiveContext(ctx, overlayGeneration)) {
-            pi.appendEntry("intercom_sent", {
-                to: selectedSession.name || selectedSession.id,
-                message: { text: result.text, expectsReply: result.expectsReply },
-                messageId: result.messageId,
-                timestamp: Date.now(),
-            });
-            notifyIfLive(ctx, `${result.expectsReply ? "Ask sent" : "Message sent"} to ${targetLabel}`, "info", overlayGeneration);
-        }
-    }
-    pi.registerCommand("intercom", {
-        description: "Open peer messaging; 'all' includes other projects, 'topics' inspects quiet topic/owner state",
-        handler: async (args, ctx) => {
-            const requestedScope = args.trim();
-            if (requestedScope === "topics") {
-                const generation = runtimeGeneration;
-                let notice;
-                try {
-                    const active = await ensureConnected("overlay");
-                    if (!active.supportsTopics) {
-                        notice = TOPICS_UNAVAILABLE;
-                        topics.disconnected();
-                    }
-                    else {
-                        const sessions = await active.listSessions();
-                        if (getLiveContext(ctx, generation))
-                            topics.refresh(sessions);
-                    }
-                }
-                catch {
-                    if (getLiveContext(ctx, generation)) {
-                        topics.disconnected();
-                        notice = "Broker unavailable; last saved topic records follow.";
-                    }
-                }
-                if (getLiveContext(ctx, generation))
-                    await topics.open(ctx, notice);
-                return;
-            }
-            if (requestedScope && requestedScope !== "all") {
-                ctx.ui.notify("Usage: /intercom [all|topics]", "warning");
-                return;
-            }
-            await openIntercomOverlay(ctx, requestedScope === "all" ? "all" : "project");
-        },
-    });
-    pi.registerShortcut(config.shortcut, {
-        description: "Toggle your agents, or open connected sessions",
-        handler: async (ctx) => {
-            const request = { ctx, handled: false };
-            pi.events.emit("subagent:open-agents", request);
-            if (!request.handled)
-                await openIntercomOverlay(ctx);
         },
     });
+    const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
+        replies,
+        syncStatus: () => connection.syncStatus(),
+    });
+    const inbound = new IntercomInbound(lifecycle, config, {
+        journal,
+        delivery,
+        replies,
+        wait,
+        connection,
+        topics,
+        child,
+    });
+    const outbound = new IntercomOutbound({ pi, lifecycle, connection, replies, wait }, config);
+    const inspection = new IntercomInspection(journal, replies);
+    const topicActions = new IntercomTopicActions({ pi, lifecycle, connection, topics });
+    const tools = new IntercomTools({ connection, outbound, topicActions, topics, inspection });
+    const supervisor = child
+        ? new IntercomSupervisor({ pi, lifecycle, connection, wait }, child)
+        : null;
+    const overlay = new IntercomOverlay({ pi, lifecycle, connection, topics });
+    const bridges = new SubagentEventBridges(lifecycle, connection, delivery, {
+        pi,
+        journal,
+        open: (ctx, scope) => overlay.open(ctx, scope),
+    });
+    const awareness = child ? null : new PeerAwareness(connection, lifecycle);
+    bridges.start();
+    new IntercomSessionEvents(pi, {
+        lifecycle,
+        connection,
+        delivery,
+        journal,
+        replies,
+        wait,
+        topics,
+        bridges,
+        supervisor,
+        awareness,
+    }).register();
+    registerMessageRenderers(pi);
+    registerIntercomTools(pi, tools, supervisor);
+    overlay.register(config.shortcut);
 }