@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/intercom/result-intercom.js

@@ -1,26 +1,43 @@
-import { randomUUID } from "node:crypto";
+import { copyDetails, copyResult } from "../extension/result-snapshot.js";
+import { compactNestedResultChildren, formatNestedResultLines } from "./nested-result-tree.js";
+export { compactNestedResultChildren, attachNestedChildrenToResultChildren, } from "./nested-result-tree.js";
+export { deliverSubagentResultIntercomEvent, deliverSubagentIntercomMessageEvent, } from "./result-delivery.js";
 import * as fs from "node:fs";
 import { formatRunAction } from "../shared/status-format.js";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.js";
-import { SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, SUBAGENT_RESULT_INTERCOM_EVENT, } from "../shared/types.js";
+function hasText(value) {
+    return value !== undefined && value.length > 0;
+}
+function completedStatus(input) {
+    if (input.success !== undefined) {
+        return input.success ? "completed" : "failed";
+    }
+    if (input.state === "complete") {
+        return "completed";
+    }
+    if (input.state === "failed") {
+        return "failed";
+    }
+    return input.exitCode === 0 ? "completed" : "failed";
+}
+function isBlockedResult(input) {
+    return ((input.exitCode === undefined || input.exitCode === 0) &&
+        (input.acceptance?.status === "blocked" || input.state === "blocked"));
+}
 export function resolveSubagentResultStatus(input) {
-    if (input.detached)
+    if (input.detached === true) {
         return "detached";
-    if (input.timedOut || input.state === "timed-out")
+    }
+    if (input.timedOut === true || input.state === "timed-out") {
         return "timed-out";
-    if (input.interrupted || input.state === "paused")
+    }
+    if (input.interrupted === true || input.state === "paused") {
         return "paused";
-    if ((input.exitCode === undefined || input.exitCode === 0) && (input.acceptance?.status === "blocked" || input.state === "blocked"))
+    }
+    if (isBlockedResult(input)) {
         return "blocked";
-    if (typeof input.success === "boolean")
-        return input.success ? "completed" : "failed";
-    if (input.state === "complete")
-        return "completed";
-    if (input.state === "failed")
-        return "failed";
-    if (typeof input.exitCode === "number")
-        return input.exitCode === 0 ? "completed" : "failed";
-    return "failed";
+    }
+    return completedStatus(input);
 }
 function countStatuses(children) {
     const counts = {
@@ -38,148 +55,99 @@ function countStatuses(children) {
 }
 function formatStatusCounts(counts) {
     const parts = [
-        counts.completed ? `${counts.completed} completed` : undefined,
-        counts.failed ? `${counts.failed} failed` : undefined,
-        counts.blocked ? `${counts.blocked} need human action` : undefined,
-        counts.paused ? `${counts.paused} paused` : undefined,
-        counts.detached ? `${counts.detached} detached` : undefined,
-        counts["timed-out"] ? `${counts["timed-out"]} timed out` : undefined,
-    ].filter((part) => Boolean(part));
-    return parts.length ? parts.join(", ") : "0 results";
+        counts.completed > 0 ? `${counts.completed} completed` : undefined,
+        counts.failed > 0 ? `${counts.failed} failed` : undefined,
+        counts.blocked > 0 ? `${counts.blocked} need human action` : undefined,
+        counts.paused > 0 ? `${counts.paused} paused` : undefined,
+        counts.detached > 0 ? `${counts.detached} detached` : undefined,
+        counts["timed-out"] > 0 ? `${counts["timed-out"]} timed out` : undefined,
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(", ") : "0 results";
 }
 function resolveGroupedStatus(children, workflowStatus) {
     const counts = countStatuses(children);
-    if (workflowStatus)
+    if (workflowStatus !== undefined) {
         counts[workflowStatus] += 1;
-    if (counts.failed > 0)
+    }
+    if (counts.failed > 0) {
         return "failed";
-    if (counts["timed-out"] > 0)
+    }
+    if (counts["timed-out"] > 0) {
         return "timed-out";
-    if (counts.blocked > 0)
+    }
+    if (counts.blocked > 0) {
         return "blocked";
-    if (counts.paused > 0)
+    }
+    if (counts.paused > 0) {
         return "paused";
-    if (counts.completed > 0)
+    }
+    if (counts.completed > 0) {
         return "completed";
-    if (counts.detached > 0)
+    }
+    if (counts.detached > 0) {
         return "detached";
+    }
     return "failed";
 }
-function compactNestedRun(run, depth = 0) {
-    return {
-        id: run.id,
-        parentRunId: run.parentRunId,
-        ...(run.parentStepIndex !== undefined ? { parentStepIndex: run.parentStepIndex } : {}),
-        ...(run.parentAgent ? { parentAgent: run.parentAgent } : {}),
-        depth: run.depth,
-        path: run.path.slice(0, 4).map((part) => ({
-            runId: part.runId,
-            ...(part.stepIndex !== undefined ? { stepIndex: part.stepIndex } : {}),
-            ...(part.agent ? { agent: part.agent } : {}),
-        })),
-        ...(run.asyncDir ? { asyncDir: run.asyncDir } : {}),
-        ...(run.sessionId ? { sessionId: run.sessionId } : {}),
-        ...(run.sessionFile ? { sessionFile: run.sessionFile } : {}),
-        ...(run.intercomTarget ? { intercomTarget: run.intercomTarget } : {}),
-        ...(run.ownerIntercomTarget ? { ownerIntercomTarget: run.ownerIntercomTarget } : {}),
-        ...(run.leafIntercomTarget ? { leafIntercomTarget: run.leafIntercomTarget } : {}),
-        ...(run.ownerState ? { ownerState: run.ownerState } : {}),
-        ...(run.mode ? { mode: run.mode } : {}),
-        state: run.state,
-        ...(run.agent ? { agent: run.agent } : {}),
-        ...(run.agents?.length ? { agents: run.agents.slice(0, 12) } : {}),
-        ...(run.currentStep !== undefined ? { currentStep: run.currentStep } : {}),
-        ...(run.chainStepCount !== undefined ? { chainStepCount: run.chainStepCount } : {}),
-        ...(run.parallelGroups?.length ? { parallelGroups: run.parallelGroups.slice(0, 8) } : {}),
-        ...(run.activityState ? { activityState: run.activityState } : {}),
-        ...(run.lastActivityAt !== undefined ? { lastActivityAt: run.lastActivityAt } : {}),
-        ...(run.currentTool ? { currentTool: run.currentTool } : {}),
-        ...(run.currentToolStartedAt !== undefined ? { currentToolStartedAt: run.currentToolStartedAt } : {}),
-        ...(run.currentPath ? { currentPath: run.currentPath } : {}),
-        ...(run.turnCount !== undefined ? { turnCount: run.turnCount } : {}),
-        ...(run.toolCount !== undefined ? { toolCount: run.toolCount } : {}),
-        ...(run.totalTokens ? { totalTokens: run.totalTokens } : {}),
-        ...(run.startedAt !== undefined ? { startedAt: run.startedAt } : {}),
-        ...(run.endedAt !== undefined ? { endedAt: run.endedAt } : {}),
-        ...(run.lastUpdate !== undefined ? { lastUpdate: run.lastUpdate } : {}),
-        ...(run.error ? { error: run.error } : {}),
-        ...(run.steps?.length ? { steps: run.steps.slice(0, 12).map((step) => ({
-                agent: step.agent,
-                status: step.status,
-                ...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
-                ...(step.activityState ? { activityState: step.activityState } : {}),
-                ...(step.lastActivityAt !== undefined ? { lastActivityAt: step.lastActivityAt } : {}),
-                ...(step.currentTool ? { currentTool: step.currentTool } : {}),
-                ...(step.currentToolStartedAt !== undefined ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
-                ...(step.currentPath ? { currentPath: step.currentPath } : {}),
-                ...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
-                ...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
-                ...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
-                ...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
-                ...(step.error ? { error: step.error } : {}),
-                ...(depth < 2 && step.children?.length ? { children: step.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) } : {}),
-            })) } : {}),
-        ...(depth < 2 && run.children?.length ? { children: run.children.slice(0, 8).map((child) => compactNestedRun(child, depth + 1)) } : {}),
-    };
-}
-export function compactNestedResultChildren(children) {
-    if (!children?.length)
-        return undefined;
-    return children.slice(0, 16).map((child) => compactNestedRun(child));
-}
-export function attachNestedChildrenToResultChildren(runId, children, nestedChildren) {
-    const compact = compactNestedResultChildren(nestedChildren);
-    if (!compact?.length)
-        return children.map((child) => ({ ...child, children: compactNestedResultChildren(child.children) }));
-    return children.map((child, index) => {
-        const childIndex = child.index ?? index;
-        const alreadyAttachedIds = new Set(child.children?.map((nested) => nested.id) ?? []);
-        const attached = compact.filter((nested) => nested.parentRunId === runId && nested.parentStepIndex === childIndex && !alreadyAttachedIds.has(nested.id));
-        const fallbackAttached = children.length === 1
-            ? compact.filter((nested) => nested.parentRunId === runId && nested.parentStepIndex === undefined && !alreadyAttachedIds.has(nested.id))
-            : [];
-        const merged = compactNestedResultChildren([...(child.children ?? []), ...attached, ...fallbackAttached]);
-        return merged?.length ? { ...child, children: merged } : { ...child, children: undefined };
-    });
-}
-function formatNestedResultLines(children) {
-    if (!children?.length)
-        return [];
-    const lines = ["Nested subagents:"];
-    let remaining = 10;
-    const append = (runs, indent) => {
-        for (const run of runs ?? []) {
-            if (remaining <= 0) {
-                lines.push(`${indent}↳ +more nested runs; inspect status for full tree`);
-                return;
-            }
-            remaining--;
-            const label = run.agent ?? run.agents?.join("+") ?? run.id;
-            lines.push(`${indent}↳ ${label} — ${run.state} [${run.id}]`);
-            if (run.sessionFile)
-                lines.push(`${indent}  Session: ${run.sessionFile}`);
-            append(run.children, `${indent}  `);
-            for (const step of run.steps ?? [])
-                append(step.children, `${indent}    `);
-        }
-    };
-    append(children, "");
-    return lines;
-}
 function asyncResumeGuidance(input) {
-    if (input.source !== "async" || !input.asyncId)
+    if (input.source !== "async" || input.asyncId === undefined || input.asyncId.length === 0) {
         return undefined;
+    }
     const childSafe = process.env[SUBAGENT_CHILD_ENV] === "1" && process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
     const resumable = input.children.filter((child) => typeof child.sessionPath === "string" && fs.existsSync(child.sessionPath));
     if (input.children.length === 1 && resumable.length === 1) {
         return `Continue: ${formatRunAction("resume", input.asyncId, { message: "..." }, childSafe)}`;
     }
-    if (resumable.length > 0) {
-        const firstIndex = resumable[0]?.index ?? input.children.indexOf(resumable[0]);
+    const first = resumable.at(0);
+    if (first) {
+        const firstIndex = first.index ?? input.children.indexOf(first);
         return `Continue child: ${formatRunAction("resume", input.asyncId, { index: firstIndex, message: "..." }, childSafe)}`;
     }
     return "Resume: unavailable; no child session file was persisted.";
 }
+function formatChildOutput(child, source) {
+    const lines = [];
+    if (hasText(child.intercomTarget)) {
+        lines.push(`${source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`);
+    }
+    if (hasText(child.artifactPath)) {
+        lines.push(`Output artifact: ${child.artifactPath}`);
+    }
+    if (hasText(child.metadataPath)) {
+        lines.push(`Result metadata (acceptance details when configured): ${child.metadataPath}${fs.existsSync(child.metadataPath) ? "" : " (missing)"}`);
+    }
+    if (hasText(child.sessionPath)) {
+        lines.push(`Session: ${child.sessionPath}`);
+    }
+    lines.push(...formatNestedResultLines(child.children), "Summary:", child.summary);
+    return lines;
+}
+function formatRunLocations(input) {
+    const lines = [];
+    if (input.mode === "chain" && input.chainSteps !== undefined) {
+        lines.push(`Chain steps: ${input.chainSteps}`);
+    }
+    for (const [field, label] of [
+        ["resultPath", "Saved result (acceptance details when configured)"],
+        ["asyncId", "Async id"],
+        ["asyncDir", "Async dir"],
+    ]) {
+        const value = input[field];
+        if (hasText(value)) {
+            lines.push(`${label}: ${value}`);
+        }
+    }
+    const guidance = asyncResumeGuidance(input);
+    if (hasText(guidance)) {
+        lines.push(guidance);
+    }
+    if (input.children.some((child) => hasText(child.intercomTarget))) {
+        lines.push("", input.source === "async"
+            ? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
+            : "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.");
+    }
+    return lines;
+}
 function formatSubagentResultIntercomMessage(input) {
     const counts = countStatuses(input.children);
     const lines = [
@@ -189,119 +157,67 @@ function formatSubagentResultIntercomMessage(input) {
         `Mode: ${input.mode}`,
         `Status: ${input.status}`,
         `Children: ${formatStatusCounts(counts)}`,
-        ...(input.error ? [`Workflow ${input.status === "paused" ? "paused" : "error"}: ${input.error}`] : []),
+        ...(hasText(input.error)
+            ? [`Workflow ${input.status === "paused" ? "paused" : "error"}: ${input.error}`]
+            : []),
     ];
     if (input.source === "foreground" && input.status === "completed") {
         lines.push("This completes the matching subagent call. Continue the parent task without relaunching the same call.");
     }
-    if (input.mode === "chain" && typeof input.chainSteps === "number") {
-        lines.push(`Chain steps: ${input.chainSteps}`);
+    lines.push(...formatRunLocations(input));
+    for (const [index, child] of input.children.entries()) {
+        lines.push("", `${index + 1}. ${child.agent} — ${child.status}`, ...formatChildOutput(child, input.source));
     }
-    if (input.resultPath)
-        lines.push(`Saved result (acceptance details when configured): ${input.resultPath}`);
-    if (input.asyncId)
-        lines.push(`Async id: ${input.asyncId}`);
-    if (input.asyncDir)
-        lines.push(`Async dir: ${input.asyncDir}`);
-    const resumeGuidance = asyncResumeGuidance(input);
-    if (resumeGuidance)
-        lines.push(resumeGuidance);
-    if (input.children.some((child) => child.intercomTarget)) {
-        lines.push("");
-        lines.push(input.source === "async"
-            ? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
-            : "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.");
+    return lines.join("\n");
+}
+function payloadLocations(input) {
+    const locations = {};
+    for (const key of ["completionId", "error", "resultPath", "asyncId", "asyncDir"]) {
+        const value = input[key];
+        if (hasText(value)) {
+            locations[key] = value;
+        }
     }
-    for (let index = 0; index < input.children.length; index++) {
-        const child = input.children[index];
-        lines.push("");
-        lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
-        if (child.intercomTarget)
-            lines.push(`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`);
-        if (child.artifactPath)
-            lines.push(`Output artifact: ${child.artifactPath}`);
-        if (child.metadataPath)
-            lines.push(`Result metadata (acceptance details when configured): ${child.metadataPath}${fs.existsSync(child.metadataPath) ? "" : " (missing)"}`);
-        if (child.sessionPath)
-            lines.push(`Session: ${child.sessionPath}`);
-        lines.push(...formatNestedResultLines(child.children));
-        lines.push("Summary:");
-        lines.push(child.summary);
+    if (input.chainSteps !== undefined) {
+        locations.chainSteps = input.chainSteps;
     }
-    return lines.join("\n");
+    return locations;
+}
+function firstChildDetails(child) {
+    if (!child) {
+        return {};
+    }
+    return {
+        ...(child.agent.length > 0 ? { agent: child.agent } : {}),
+        ...(child.index !== undefined ? { index: child.index } : {}),
+        ...(hasText(child.artifactPath) ? { artifactPath: child.artifactPath } : {}),
+        ...(hasText(child.sessionPath) ? { sessionPath: child.sessionPath } : {}),
+    };
 }
 export function buildSubagentResultIntercomPayload(input) {
-    const children = input.children.map((child) => ({
-        ...child,
-        summary: child.summary.trim() || "(no output)",
+    const children = input.children.map((child) => Object.assign({}, child, {
+        summary: child.summary.trim().length > 0 ? child.summary.trim() : "(no output)",
         children: compactNestedResultChildren(child.children),
     }));
     const status = resolveGroupedStatus(children, input.status);
     const summary = formatStatusCounts(countStatuses(children));
-    const firstChild = children[0];
+    const firstChild = children.at(0);
     const payload = {
-        ...(input.completionId ? { completionId: input.completionId } : {}),
+        ...payloadLocations(input),
         to: input.to,
         runId: input.runId,
         mode: input.mode,
         status,
         summary,
-        ...(input.error ? { error: input.error } : {}),
         source: input.source,
         children,
-        ...(input.resultPath ? { resultPath: input.resultPath } : {}),
-        ...(input.asyncId ? { asyncId: input.asyncId } : {}),
-        ...(input.asyncDir ? { asyncDir: input.asyncDir } : {}),
-        ...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
-        ...(firstChild?.agent ? { agent: firstChild.agent } : {}),
-        ...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
-        ...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),
-        ...(firstChild?.sessionPath ? { sessionPath: firstChild.sessionPath } : {}),
-        message: "",
+        ...firstChildDetails(firstChild),
     };
-    payload.message = formatSubagentResultIntercomMessage(payload);
-    return payload;
-}
-export async function deliverSubagentResultIntercomEvent(events, payload, timeoutMs = 500) {
-    return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, { ...payload });
-}
-export async function deliverSubagentIntercomMessageEvent(events, to, message, timeoutMs = 500, extra = {}) {
-    if (typeof events.on !== "function" || typeof events.emit !== "function")
-        return false;
-    const requestId = typeof extra.requestId === "string" ? extra.requestId : randomUUID();
-    return new Promise((resolve) => {
-        let settled = false;
-        let unsubscribe;
-        let timer;
-        const finish = (delivered) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            unsubscribe?.();
-            resolve(delivered);
-        };
-        unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
-            if (!data || typeof data !== "object")
-                return;
-            const delivery = data;
-            if (delivery.requestId !== requestId)
-                return;
-            finish(delivery.delivered === true);
-        });
-        timer = setTimeout(() => finish(false), timeoutMs);
-        try {
-            events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
-        }
-        catch {
-            finish(false);
-        }
-    });
+    return { ...payload, message: formatSubagentResultIntercomMessage(payload) };
 }
 function stripSingleResultOutputs(result) {
     return {
-        ...result,
+        ...copyResult(result),
         messages: undefined,
         finalOutput: undefined,
         truncation: undefined,
@@ -309,7 +225,7 @@ function stripSingleResultOutputs(result) {
 }
 export function stripDetailsOutputsForIntercomReceipt(details, delivery) {
     return {
-        ...details,
+        ...copyDetails(details),
         results: details.results.map(stripSingleResultOutputs),
         ...(delivery ? { intercomDelivery: delivery } : {}),
     };
@@ -319,55 +235,56 @@ function compactReceiptSummary(summary) {
     const normalized = withoutOutput.replace(/\s+/g, " ").trim();
     return normalized.length > 240 ? `${normalized.slice(0, 239)}…` : normalized;
 }
-export function formatSubagentResultReceipt(input) {
-    const counts = countStatuses(input.payload.children);
-    const modeLabel = input.mode === "single"
-        ? "single subagent result"
-        : input.mode === "parallel"
-            ? "parallel subagent results"
-            : "chain subagent results";
-    const lines = [
-        `Delivered ${modeLabel} via intercom.`,
-        "Delivery: succeeded",
-        `Run: ${input.runId}`,
-        `Child outcome: ${input.payload.status}`,
-        `Children: ${formatStatusCounts(counts)}`,
-        ...(input.payload.error ? [`Workflow ${input.payload.status === "paused" ? "paused" : "error"}: ${input.payload.error}`] : []),
-    ];
-    if (input.payload.resultPath)
-        lines.push(`Saved result (acceptance details when configured): ${input.payload.resultPath}`);
-    for (const child of input.payload.children) {
-        if (child.metadataPath)
-            lines.push(`Result metadata (${child.agent}; acceptance details when configured): ${child.metadataPath}${fs.existsSync(child.metadataPath) ? "" : " (missing)"}`);
-    }
-    const artifacts = input.payload.children.filter((child) => typeof child.artifactPath === "string");
-    if (artifacts.length > 0) {
-        lines.push("Artifacts:");
-        for (const child of artifacts) {
-            lines.push(`- ${child.agent} [${child.status}]: ${child.artifactPath}`);
+function formatChildReferences(children, field, heading) {
+    const lines = [];
+    for (const child of children) {
+        const value = child[field];
+        if (typeof value === "string") {
+            lines.push(`- ${child.agent} [${child.status}]: ${value}`);
         }
     }
-    const intercomTargets = input.payload.children.filter((child) => typeof child.intercomTarget === "string");
-    if (intercomTargets.length > 0) {
-        lines.push("Run intercom targets (may be inactive after completion):");
-        for (const child of intercomTargets) {
-            lines.push(`- ${child.agent} [${child.status}]: ${child.intercomTarget}`);
-        }
+    return lines.length > 0 ? [heading, ...lines] : [];
+}
+function formatReceiptReferences(payload) {
+    const lines = [];
+    if (hasText(payload.resultPath)) {
+        lines.push(`Saved result (acceptance details when configured): ${payload.resultPath}`);
     }
-    const sessions = input.payload.children.filter((child) => typeof child.sessionPath === "string");
-    if (sessions.length > 0) {
-        lines.push("Sessions:");
-        for (const child of sessions) {
-            lines.push(`- ${child.agent} [${child.status}]: ${child.sessionPath}`);
+    for (const child of payload.children) {
+        if (hasText(child.metadataPath)) {
+            lines.push(`Result metadata (${child.agent}; acceptance details when configured): ${child.metadataPath}${fs.existsSync(child.metadataPath) ? "" : " (missing)"}`);
         }
     }
-    const nonCompleted = input.payload.children.filter((child) => child.status !== "completed");
+    lines.push(...formatChildReferences(payload.children, "artifactPath", "Artifacts:"), ...formatChildReferences(payload.children, "intercomTarget", "Run intercom targets (may be inactive after completion):"), ...formatChildReferences(payload.children, "sessionPath", "Sessions:"));
+    const nonCompleted = payload.children.filter((child) => child.status !== "completed");
     if (nonCompleted.length > 0) {
         lines.push("Non-completed children:");
         for (const child of nonCompleted) {
             lines.push(`- ${child.agent} [${child.status}]: ${compactReceiptSummary(child.summary)}`);
         }
     }
+    return lines;
+}
+export function formatSubagentResultReceipt(input) {
+    const counts = countStatuses(input.payload.children);
+    const modeLabel = {
+        single: "single subagent result",
+        parallel: "parallel subagent results",
+        chain: "chain subagent results",
+    }[input.mode];
+    const lines = [
+        `Delivered ${modeLabel} via intercom.`,
+        "Delivery: succeeded",
+        `Run: ${input.runId}`,
+        `Child outcome: ${input.payload.status}`,
+        `Children: ${formatStatusCounts(counts)}`,
+        ...(hasText(input.payload.error)
+            ? [
+                `Workflow ${input.payload.status === "paused" ? "paused" : "error"}: ${input.payload.error}`,
+            ]
+            : []),
+    ];
+    lines.push(...formatReceiptReferences(input.payload));
     lines.push("Full grouped output was sent over intercom.");
     return lines.join("\n");
 }

package/dist/pi-intercom/agent-dir.js

@@ -2,9 +2,13 @@ import { homedir } from "os";
 import { join } from "path";
 export function getPiAgentDir() {
     const configured = process.env.PI_CODING_AGENT_DIR?.trim();
-    if (configured === "~")
+    if (configured === "~") {
         return homedir();
-    if (configured?.startsWith("~/"))
+    }
+    if (configured?.startsWith("~/") === true) {
         return join(homedir(), configured.slice(2));
-    return configured || join(homedir(), ".pi", "agent");
+    }
+    return configured === undefined || configured === ""
+        ? join(homedir(), ".pi", "agent")
+        : configured;
 }

package/dist/pi-intercom/async.js

@@ -0,0 +1,27 @@
+/** Bounded observation; the caller continues to own the underlying operation. */
+export 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();
+        Promise.resolve()
+            .then(operation)
+            .then((value) => {
+            finish(value);
+        }, () => {
+            finish(null);
+        })
+            .catch(() => {
+            // Both terminal handlers are synchronous; retain rejection ownership if a native timer fails.
+            finish(null);
+        });
+    });
+}

package/dist/pi-intercom/bridge-ask.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import { Fault } from "./bridge-protocol.js";
+/** Owns correlation, the early rejection observer and the outgoing ask deadline. */
+export class WaitingAsk {
+    id = randomUUID();
+    reply;
+    resolveReply;
+    rejectReply;
+    timer;
+    peer;
+    settledState = false;
+    receipt;
+    constructor() {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        this.reply = promise;
+        this.resolveReply = resolve;
+        this.rejectReply = reject;
+        promise.catch(() => {
+            // Consume early rejection during lookup/ack; the request later awaits the original reply.
+        });
+    }
+    get settled() {
+        return this.settledState;
+    }
+    resolve(answer) {
+        this.settledState = true;
+        this.clear();
+        this.resolveReply(answer);
+    }
+    reject(error) {
+        this.settledState = true;
+        this.clear();
+        this.rejectReply(error);
+    }
+    matches(peer, replyTo) {
+        return !this.settled && this.id === replyTo && this.peer === peer;
+    }
+    clear() {
+        clearTimeout(this.timer);
+    }
+    deadline(timeoutMs, close) {
+        this.timer = setTimeout(() => {
+            const fault = new Fault(504, "ask_timeout", "Peer did not reply before the ask deadline.", {
+                id: this.id,
+                ...(this.receipt
+                    ? { accepted: this.receipt.accepted, delivered: this.receipt.delivered }
+                    : { deliveryUnknown: true }),
+            });
+            if (this.receipt) {
+                this.reject(fault);
+            }
+            else {
+                close(fault);
+            }
+        }, timeoutMs);
+    }
+}