@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/pi-intercom/ui/overlay.js

@@ -0,0 +1,181 @@
+import { TOPICS_UNAVAILABLE } from "../runtime-types.js";
+import { errorMessage } from "../validation.js";
+import { targetDisplayName } from "../session-targets.js";
+import { sessionsForScope } from "./session-format.js";
+import { SessionListOverlay } from "./session-list.js";
+import { ComposeOverlay } from "./compose.js";
+function sentResult(result) {
+    if (result?.sent !== true) {
+        return null;
+    }
+    const messageId = result.messageId ?? "";
+    const text = result.text ?? "";
+    return messageId === "" || text === ""
+        ? null
+        : { messageId, text, expectsReply: result.expectsReply === true };
+}
+export class IntercomOverlay {
+    owners;
+    constructor(owners) {
+        this.owners = owners;
+    }
+    notify(ctx, generation, message) {
+        this.owners.lifecycle.notify(ctx, message, "error", generation);
+    }
+    async connect(ctx, generation) {
+        try {
+            return await this.owners.connection.ensure("overlay");
+        }
+        catch (error) {
+            this.notify(ctx, generation, `Intercom unavailable: ${errorMessage(error)}`);
+            return null;
+        }
+    }
+    async choices(active, scope) {
+        const id = active.sessionId;
+        if (id === null || id === "") {
+            throw new Error("Current intercom session id is unavailable.");
+        }
+        const all = await active.listSessions();
+        const current = all.find((session) => session.id === id);
+        if (!current) {
+            throw new Error("Current session is missing from intercom session list");
+        }
+        const scoped = sessionsForScope(all, id, scope);
+        return {
+            current,
+            peers: scoped.filter((session) => session.id !== id),
+            all,
+            hidden: all.length - scoped.length,
+        };
+    }
+    async select(ctx, choices) {
+        return await ctx.ui
+            .custom((tui, theme, keybindings, done) => new SessionListOverlay(tui, theme, {
+            keybindings,
+            currentSession: choices.current,
+            sessions: choices.peers,
+            done,
+            hiddenSessionCount: choices.hidden,
+            allSessions: choices.all,
+        }), { overlay: true })
+            .catch(() => null);
+    }
+    async compose(ctx, active, selected, all) {
+        return await ctx.ui
+            .custom((tui, theme, keybindings, done) => new ComposeOverlay(tui, theme, {
+            keybindings,
+            target: selected,
+            targetLabel: targetDisplayName(selected, all),
+            client: active,
+            done,
+        }), { overlay: true })
+            .catch(() => null);
+    }
+    async choose(ctx, scope, generation) {
+        const active = await this.connect(ctx, generation);
+        if (!active || !this.owners.lifecycle.live(ctx, generation)) {
+            return null;
+        }
+        this.owners.connection.syncIdentity(ctx.sessionManager.getSessionId());
+        let choices;
+        try {
+            choices = await this.choices(active, scope);
+        }
+        catch (error) {
+            this.notify(ctx, generation, `Failed to list sessions: ${errorMessage(error)}`);
+            return null;
+        }
+        if (!this.owners.lifecycle.live(ctx, generation)) {
+            return null;
+        }
+        const selected = await this.select(ctx, choices);
+        return selected ? { selected, all: choices.all } : null;
+    }
+    record(ctx, generation, sent, selection) {
+        if (!this.owners.lifecycle.live(ctx, generation)) {
+            return;
+        }
+        const { selected, all } = selection;
+        this.owners.pi.appendEntry("intercom_sent", {
+            to: selected.name === undefined || selected.name === "" ? selected.id : selected.name,
+            message: { text: sent.text, expectsReply: sent.expectsReply },
+            messageId: sent.messageId,
+            timestamp: Date.now(),
+        });
+        this.owners.lifecycle.notify(ctx, `${sent.expectsReply ? "Ask sent" : "Message sent"} to ${targetDisplayName(selected, all)}`, "info", generation);
+    }
+    async open(ctx, scope = "project") {
+        const generation = this.owners.lifecycle.generation;
+        const live = this.owners.lifecycle.live(ctx, generation);
+        if (!live || !live.hasUI || live.mode !== "tui") {
+            return;
+        }
+        const selection = await this.choose(ctx, scope, generation);
+        if (!selection || !this.owners.lifecycle.live(ctx, generation)) {
+            return;
+        }
+        const active = await this.connect(ctx, generation);
+        if (!active || !this.owners.lifecycle.live(ctx, generation)) {
+            return;
+        }
+        const sent = sentResult(await this.compose(ctx, active, selection.selected, selection.all));
+        if (sent) {
+            this.record(ctx, generation, sent, selection);
+        }
+    }
+    async topics(ctx) {
+        const generation = this.owners.lifecycle.generation;
+        let notice;
+        try {
+            const active = await this.owners.connection.ensure("overlay");
+            if (!active.supportsTopics) {
+                notice = TOPICS_UNAVAILABLE;
+                this.owners.topics.disconnected();
+            }
+            else {
+                const sessions = await active.listSessions();
+                if (this.owners.lifecycle.live(ctx, generation)) {
+                    this.owners.topics.refresh(sessions);
+                }
+            }
+        }
+        catch {
+            if (this.owners.lifecycle.live(ctx, generation)) {
+                this.owners.topics.disconnected();
+                notice = "Broker unavailable; last saved topic records follow.";
+            }
+        }
+        if (this.owners.lifecycle.live(ctx, generation) && ctx.mode === "tui") {
+            await this.owners.topics.open(ctx, notice);
+        }
+    }
+    register(shortcut) {
+        this.owners.pi.registerCommand("intercom", {
+            description: "Open peer messaging; 'all' includes other projects, 'topics' inspects quiet topic/owner state",
+            handler: async (args, ctx) => {
+                const scope = args.trim();
+                if (scope === "topics") {
+                    await this.topics(ctx);
+                    return;
+                }
+                if (scope !== "" && scope !== "all") {
+                    ctx.ui.notify("Usage: /intercom [all|topics]", "warning");
+                    return;
+                }
+                await this.open(ctx, scope === "all" ? "all" : "project");
+            },
+        });
+        this.owners.pi.registerShortcut(shortcut, {
+            description: "Toggle your agents, or open connected sessions",
+            handler: async (ctx) => {
+                // The event contract intentionally permits its owner to mark the request handled synchronously.
+                const request = { ctx, handled: false };
+                this.owners.pi.events.emit("subagent:open-agents", request);
+                if (!request.handled) {
+                    await this.open(ctx);
+                }
+            },
+        });
+    }
+}

package/dist/pi-intercom/ui/session-format.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { filterProjectSessions, formatSessionTarget } from "../session-targets.js";
+const PACKAGE_ROOT = fileURLToPath(new URL("../../../", import.meta.url));
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function localForkStartCommand() {
+    return `pi --name worker --extension ${shellQuote(path.join(PACKAGE_ROOT, "src", "pi-intercom", "index.ts"))} --skill ${shellQuote(path.join(PACKAGE_ROOT, "skills", "pi-intercom"))}`;
+}
+function duplicateNames(sessions) {
+    const names = sessions
+        .map((session) => session.name?.toLowerCase())
+        .filter((name) => name !== undefined && name !== "");
+    return new Set(names.filter((name, index) => names.indexOf(name) !== index));
+}
+export function formatDuration(seconds) {
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    return seconds < 3600 ? `${Math.floor(seconds / 60)}m` : `${Math.floor(seconds / 3600)}h`;
+}
+export function sessionBusyState(session) {
+    if (session.acceptsAsks === true) {
+        return "idle";
+    }
+    if (session.acceptsAsks === false) {
+        return "busy";
+    }
+    const status = session.status ?? "";
+    if (status === "idle" || ["idle ", "idle ·"].some((prefix) => status.startsWith(prefix))) {
+        return "idle";
+    }
+    if (status === "thinking" ||
+        ["thinking ", "thinking ·", "tool:"].some((prefix) => status.startsWith(prefix))) {
+        return "busy";
+    }
+    return "unknown";
+}
+function age(timestamp, now) {
+    return typeof timestamp === "number" && timestamp > 0
+        ? `${formatDuration(Math.max(0, Math.floor((now - timestamp) / 1000)))} ago`
+        : "none";
+}
+function guidance(session, self) {
+    if (self) {
+        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 healthTags(session, now) {
+    const tags = [
+        `state:${sessionBusyState(session)}`,
+        `accepts_asks:${session.acceptsAsks === undefined ? "unknown" : String(session.acceptsAsks)}`,
+        `pending_asks:${typeof session.pendingAsks === "number" ? session.pendingAsks : "unknown"}`,
+        `last_intercom_activity:${age(session.lastIntercomActivity, now)}`,
+    ];
+    if (typeof session.lastSeen === "number") {
+        tags.push(`last_seen:${formatDuration(Math.max(0, Math.floor((now - session.lastSeen) / 1000)))} ago`);
+    }
+    return tags;
+}
+function row(session, options) {
+    const name = session.name === undefined || session.name === "" ? "Unnamed session" : session.name;
+    const duplicate = session.name !== undefined &&
+        session.name !== "" &&
+        options.duplicates(session.name.toLowerCase());
+    let location;
+    if (options.self) {
+        location = "self";
+    }
+    else if (session.cwd === options.currentCwd) {
+        location = "same native session cwd";
+    }
+    const tags = [
+        location,
+        session.status,
+        duplicate ? `target:${formatSessionTarget(session, options.allSessions)}` : undefined,
+        ...healthTags(session, options.now),
+    ].filter((tag) => tag !== undefined && tag !== "");
+    const target = formatSessionTarget(session, options.allSessions);
+    const suffix = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+    return `• ${name} (${target}) — Native session cwd: ${session.cwd} (${session.model})${suffix}\n  ↳ ${guidance(session, options.self)}`;
+}
+export function sessionsForScope(sessions, currentSessionId, scope) {
+    return scope === "all" ? sessions : filterProjectSessions(sessions, currentSessionId);
+}
+function noPeers(hidden) {
+    if (hidden > 0) {
+        return "No other sessions connected in this project.";
+    }
+    return `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()}\`.`;
+}
+export function formatSessionListSections(allSessions, id, scope = "project") {
+    const current = allSessions.find((session) => session.id === id);
+    if (!current) {
+        throw new Error("Current session is missing from intercom session list.");
+    }
+    const scoped = sessionsForScope(allSessions, id, scope);
+    const hidden = allSessions.length - scoped.length;
+    const others = scoped.filter((session) => session.id !== id);
+    const options = {
+        currentCwd: current.cwd,
+        duplicates: (name) => duplicateNames(allSessions).has(name),
+        allSessions,
+        now: Date.now(),
+    };
+    const currentSection = `**Current session:**\n${row(current, { ...options, self: true })}`;
+    const otherSection = `**Other sessions:**\n${others.length === 0 ? noPeers(hidden) : others.map((session) => row(session, { ...options, self: false })).join("\n")}`;
+    const hint = hidden > 0
+        ? `\n\n${hidden} session${hidden === 1 ? "" : "s"} in other projects hidden. Use \`intercom({ action: "list", scope: "all" })\` to show every connected session.`
+        : "";
+    return `${currentSection}\n\n${otherSection}${hint}`;
+}

package/dist/pi-intercom/ui/session-list.js

@@ -1,8 +1,15 @@
-import { Box, Container, SelectList, Text, sliceByColumn, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { Box, Container, SelectList, Text, sliceByColumn, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 import { actionHints } from "../../tui/action-hints.js";
 import { formatSessionTarget } from "../session-targets.js";
 function sessionTitle(session, allSessions, suffix) {
-    return `${session.name || "Unnamed session"} (${formatSessionTarget(session, allSessions)})${suffix ? ` [${suffix}]` : ""}`;
+    return `${(session.name ?? "").length > 0 ? (session.name ?? "") : "Unnamed session"} (${formatSessionTarget(session, allSessions)})${suffix !== undefined && suffix.length > 0 ? ` [${suffix}]` : ""}`;
+}
+function sessionDescription(session) {
+    const resources = session.topics
+        ?.filter((topic) => (topic.resource ?? "").length > 0 && topic.ownership === "held")
+        .map((topic) => `Using ${topic.resource ?? ""}`)
+        .join(" · ") ?? "";
+    return `${resources.length > 0 ? resources : `Native session cwd: ${session.cwd}`} • ${session.model}`;
 }
 export class SessionListOverlay extends Container {
     completed = false;
@@ -10,25 +17,20 @@ export class SessionListOverlay extends Container {
     allSessions;
     tui;
     theme;
-    keybindings;
-    currentSession;
-    sessions;
-    done;
+    options;
     hiddenSessionCount;
-    constructor(tui, theme, keybindings, currentSession, sessions, done, hiddenSessionCount = 0, allSessions = [currentSession, ...sessions]) {
+    constructor(tui, theme, options) {
         super();
         this.tui = tui;
         this.theme = theme;
-        this.keybindings = keybindings;
-        this.currentSession = currentSession;
-        this.sessions = sessions;
-        this.done = done;
-        this.hiddenSessionCount = hiddenSessionCount;
-        this.allSessions = allSessions;
+        this.options = options;
+        const { sessions, currentSession } = options;
+        this.hiddenSessionCount = options.hiddenSessionCount ?? 0;
+        this.allSessions = options.allSessions ?? [currentSession, ...sessions];
         const items = sessions.map((session) => ({
             value: session.id,
             label: sessionTitle(session, this.allSessions, session.cwd === currentSession.cwd ? "same native session cwd" : undefined),
-            description: `${session.topics?.filter((topic) => topic.resource && topic.ownership === "held").map((topic) => `Using ${topic.resource}`).join(" · ") || `Native session cwd: ${session.cwd}`} • ${session.model}`,
+            description: sessionDescription(session),
         }));
         this.selectList = new SelectList(items, 8, {
             selectedPrefix: (text) => theme.fg("accent", text),
@@ -41,38 +43,83 @@ export class SessionListOverlay extends Container {
         this.selectList.onCancel = () => this.finish();
     }
     finish(result) {
-        if (this.completed)
+        if (this.completed) {
             return;
+        }
+        this.completed = true;
+        this.options.done(result);
+    }
+    dispose() {
         this.completed = true;
-        this.done(result);
     }
-    dispose() { this.completed = true; }
     handleMouse(event) {
         const width = Math.min(event.width, 88);
-        if (this.completed || event.x >= width)
+        if (this.completed || event.x >= width) {
             return;
+        }
         return super.handleMouse({ ...event, width });
     }
     handleInput(data) {
-        if (this.completed)
+        if (this.completed) {
             return;
-        if (this.sessions.length === 0) {
-            if (this.keybindings.matches(data, "tui.select.cancel"))
+        }
+        if (this.options.sessions.length === 0) {
+            if (this.options.keybindings.matches(data, "tui.select.cancel")) {
                 this.finish();
+            }
         }
         else {
             this.selectList.handleInput(data);
         }
         this.tui.requestRender();
     }
+    emptyLines(row) {
+        const messages = this.hiddenSessionCount > 0
+            ? [
+                " No other sessions in this project",
+                ` ${this.hiddenSessionCount} in other project${this.hiddenSessionCount === 1 ? "" : "s"} hidden`,
+                " Run /intercom all to show every connected session",
+            ]
+            : [
+                " No other intercom-connected sessions",
+                " Start another session with: pi --name worker",
+                ' Then run intercom({ action: "list" }) again',
+            ];
+        return messages.map((message) => row(this.theme.fg("dim", message)));
+    }
+    controls() {
+        const message = [this.options.keybindings.getKeys("tui.select.confirm").join("/"), "Message"]
+            .filter(Boolean)
+            .join(": ");
+        const close = [this.options.keybindings.getKeys("tui.select.cancel").join("/"), "Close"]
+            .filter(Boolean)
+            .join(": ");
+        return actionHints([
+            " ",
+            ...(this.options.sessions.length > 0
+                ? [
+                    {
+                        text: message,
+                        run: () => {
+                            const item = this.selectList.getSelectedItem();
+                            if (item) {
+                                this.selectList.onSelect?.(item);
+                            }
+                        },
+                    },
+                    " • ",
+                ]
+                : []),
+            { text: close, run: () => this.finish() },
+        ], (text) => this.theme.fg("dim", text), "");
+    }
     render(width) {
         this.clear();
-        if (width < 3)
+        if (width < 3) {
             return [truncateToWidth("Intercom", width)];
+        }
         const innerWidth = Math.min(width, 88);
         const contentWidth = Math.max(1, innerWidth - 2);
-        const message = [this.keybindings.getKeys("tui.select.confirm").join("/"), "Message"].filter(Boolean).join(": ");
-        const close = [this.keybindings.getKeys("tui.select.cancel").join("/"), "Close"].filter(Boolean).join(": ");
         const border = (text) => this.theme.fg("accent", text);
         const row = (text = "") => {
             const clipped = truncateToWidth(text, contentWidth, "", true);
@@ -87,24 +134,14 @@ export class SessionListOverlay extends Container {
             border(`╭${"─".repeat(contentWidth)}╮`),
             row(this.theme.bold(" Current Session")),
             border(`├${"─".repeat(contentWidth)}┤`),
-            row(`  ${this.theme.fg("dim", sessionTitle(this.currentSession, this.allSessions, "self"))}`),
-            row(`  ${this.theme.fg("dim", `Native session cwd: ${this.currentSession.cwd} • ${this.currentSession.model}`)}`),
+            row(`  ${this.theme.fg("dim", sessionTitle(this.options.currentSession, this.allSessions, "self"))}`),
+            row(`  ${this.theme.fg("dim", `Native session cwd: ${this.options.currentSession.cwd} • ${this.options.currentSession.model}`)}`),
             border(`├${"─".repeat(contentWidth)}┤`),
             row(this.theme.bold(" Other Sessions")),
         ];
         this.addChild(new Text(lines.join("\n"), 0, 0));
-        if (this.sessions.length === 0) {
-            this.addChild(new Text((this.hiddenSessionCount > 0
-                ? [
-                    row(this.theme.fg("dim", " No other sessions in this project")),
-                    row(this.theme.fg("dim", ` ${this.hiddenSessionCount} in other project${this.hiddenSessionCount === 1 ? "" : "s"} hidden`)),
-                    row(this.theme.fg("dim", " Run /intercom all to show every connected session")),
-                ]
-                : [
-                    row(this.theme.fg("dim", " No other intercom-connected sessions")),
-                    row(this.theme.fg("dim", " Start another session with: pi --name worker")),
-                    row(this.theme.fg("dim", " Then run intercom({ action: \"list\" }) again")),
-                ]).join("\n"), 0, 0));
+        if (this.options.sessions.length === 0) {
+            this.addChild(new Text(this.emptyLines(row).join("\n"), 0, 0));
         }
         else {
             this.addChild(framed(this.selectList));
@@ -113,11 +150,7 @@ export class SessionListOverlay extends Container {
             }
         }
         this.addChild(new Text(border(`├${"─".repeat(contentWidth)}┤`), 0, 0));
-        this.addChild(framed(actionHints([
-            " ", ...(this.sessions.length ? [{ text: message, run: () => { const item = this.selectList.getSelectedItem(); if (item)
-                        this.selectList.onSelect?.(item); } }, " • "] : []),
-            { text: close, run: () => this.finish() },
-        ], (text) => this.theme.fg("dim", text), "")));
+        this.addChild(framed(this.controls()));
         this.addChild(new Text(border(`╰${"─".repeat(contentWidth)}╯`), 0, 0));
         return super.render(innerWidth);
     }

package/dist/pi-intercom/ui/tool-renderers.js

@@ -0,0 +1,110 @@
+import { keyText } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { previewText } from "../message-format.js";
+import { firstTextContent } from "../tool-results.js";
+import { isRecord, isUnknownArray } from "../validation.js";
+function failed(context, details) {
+    return context.isError === true || details?.error === true || details?.accepted === false;
+}
+function contactColor(reason) {
+    if (reason === "need_decision") {
+        return "warning";
+    }
+    return reason === "progress_update" ? "muted" : "accent";
+}
+export function renderContactCall(args, theme) {
+    const record = isRecord(args) ? args : {};
+    const reason = typeof record.reason === "string" ? record.reason : "contact";
+    const preview = previewText(record.message, 96);
+    const interview = isRecord(record.interview) ? record.interview : undefined;
+    let text = theme.fg("toolTitle", theme.bold("contact_supervisor ")) +
+        theme.fg(contactColor(reason), reason);
+    if (typeof interview?.title === "string" && interview.title.trim() !== "") {
+        text += ` ${theme.fg("accent", interview.title.trim())}`;
+    }
+    if (preview !== undefined && preview !== "") {
+        text += `\n  ${theme.fg("dim", preview)}`;
+    }
+    return new Text(text, 0, 0);
+}
+export function renderContactResult(result, options, theme, context) {
+    if (options.isPartial) {
+        return new Text(theme.fg("warning", "Waiting for supervisor..."), 0, 0);
+    }
+    const details = isRecord(result.details) ? result.details : undefined;
+    const failure = failed(context, details);
+    const warning = typeof details?.structuredReplyParseError === "string";
+    let prefix = theme.fg("success", "✓ ");
+    if (failure) {
+        prefix = theme.fg("error", "✗ ");
+    }
+    else if (warning) {
+        prefix = theme.fg("warning", "⚠ ");
+    }
+    let text = prefix + theme.fg(failure ? "error" : "text", firstTextContent(result));
+    if (typeof details?.structuredReplyParseError === "string") {
+        text += `\n${theme.fg("warning", `Structured reply parse issue: ${details.structuredReplyParseError}`)}`;
+    }
+    return new Text(text, 0, 0);
+}
+function actionColor(action) {
+    if (action === "ask") {
+        return "warning";
+    }
+    return action === "reply" ? "success" : "accent";
+}
+export function renderIntercomCall(args, theme) {
+    const record = isRecord(args) ? args : {};
+    const action = typeof record.action === "string" ? record.action : "intercom";
+    const target = typeof record.to === "string" ? record.to.trim() : "";
+    const preview = previewText(record.message, 96);
+    const count = isUnknownArray(record.attachments) ? record.attachments.length : 0;
+    let text = theme.fg("toolTitle", theme.bold("intercom ")) + theme.fg(actionColor(action), action);
+    if (target !== "") {
+        text += ` ${theme.fg("muted", "→")} ${theme.fg("accent", target)}`;
+    }
+    if (count > 0) {
+        text += ` ${theme.fg("dim", `(${count} attachment${count === 1 ? "" : "s"})`)}`;
+    }
+    if (preview !== undefined && preview !== "") {
+        text += `\n  ${theme.fg("dim", preview)}`;
+    }
+    return new Text(text, 0, 0);
+}
+function listSummary(details, theme) {
+    const count = details?.sessionCount;
+    const summary = typeof count === "number" ? `${count} session${count === 1 ? "" : "s"}` : "Sessions listed";
+    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);
+}
+function messageSuffix(details, expanded, theme) {
+    const id = details?.messageId;
+    return typeof id === "string" && id !== "" && !expanded
+        ? theme.fg("dim", ` (${id.slice(0, 8)})`)
+        : "";
+}
+function reasonSuffix(details, expanded, theme) {
+    const reason = details?.reason;
+    return typeof reason === "string" && reason !== "" && expanded
+        ? `\n${theme.fg("dim", `Reason: ${reason}`)}`
+        : "";
+}
+function renderedText(result, failure, theme) {
+    return (theme.fg(failure ? "error" : "success", failure ? "✗ " : "✓ ") +
+        theme.fg(failure ? "error" : "text", firstTextContent(result)));
+}
+export function renderIntercomResult(result, options, theme, context) {
+    if (options.isPartial) {
+        return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
+    }
+    const details = isRecord(result.details) ? result.details : undefined;
+    const failure = failed(context, details);
+    const action = isRecord(context.args) ? context.args.action : undefined;
+    if (!failure && action === "list" && options.expanded !== true) {
+        return listSummary(details, theme);
+    }
+    const text = renderedText(result, failure, theme) +
+        messageSuffix(details, options.expanded === true, theme) +
+        reasonSuffix(details, options.expanded === true, theme);
+    return new Text(text, 0, 0);
+}