@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/agents/subagent-announce.js

@@ -1,9 +1,12 @@
 import { resolveQueueSettings } from "../auto-reply/reply/queue.js";
 import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";
+import { DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "../config/agent-limits.js";
 import { loadConfig } from "../config/config.js";
 import { loadSessionStore, resolveAgentIdFromSessionKey, resolveMainSessionKey, resolveStorePath, } from "../config/sessions.js";
 import { callGateway } from "../gateway/call.js";
-import { normalizeMainKey } from "../routing/session-key.js";
+import { createBoundDeliveryRouter } from "../infra/outbound/bound-delivery-router.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
+import { normalizeAccountId, normalizeMainKey } from "../routing/session-key.js";
 import { defaultRuntime } from "../runtime.js";
 import { extractTextFromChatContent } from "../shared/chat-content.js";
 import { deliveryContextFromSession, mergeDeliveryContext, normalizeDeliveryContext, } from "../utils/delivery-context.js";
@@ -12,11 +15,26 @@ import { buildAnnounceIdFromChildRun, buildAnnounceIdempotencyKey, resolveQueueA
 import { isEmbeddedPiRunActive, queueEmbeddedPiMessage, waitForEmbeddedPiRunEnd, } from "./pi-embedded.js";
 import { enqueueAnnounce } from "./subagent-announce-queue.js";
 import { getSubagentDepthFromSessionStore } from "./subagent-depth.js";
+import { readLatestAssistantReply } from "./tools/agent-step.js";
 import { sanitizeTextContent, extractAssistantText } from "./tools/sessions-helpers.js";
 function buildCompletionDeliveryMessage(params) {
     const findingsText = params.findings.trim();
     const hasFindings = findingsText.length > 0 && findingsText !== "(no output)";
-    const header = `✅ Subagent ${params.subagentName} finished`;
+    const header = (() => {
+        if (params.outcome?.status === "error") {
+            return params.spawnMode === "session"
+                ? `❌ Subagent ${params.subagentName} failed this task (session remains active)`
+                : `❌ Subagent ${params.subagentName} failed`;
+        }
+        if (params.outcome?.status === "timeout") {
+            return params.spawnMode === "session"
+                ? `⏱️ Subagent ${params.subagentName} timed out on this task (session remains active)`
+                : `⏱️ Subagent ${params.subagentName} timed out`;
+        }
+        return params.spawnMode === "session"
+            ? `✅ Subagent ${params.subagentName} completed this task (session remains active)`
+            : `✅ Subagent ${params.subagentName} finished`;
+    })();
     if (!hasFindings) {
         return header;
     }
@@ -74,6 +92,16 @@ function extractToolResultText(content) {
     });
     return joined?.trim() ?? "";
 }
+function extractInlineTextContent(content) {
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return (extractTextFromChatContent(content, {
+        sanitizeText: sanitizeTextContent,
+        normalizeText: (text) => text.trim(),
+        joinWith: "",
+    }) ?? "");
+}
 function extractSubagentOutputText(message) {
     if (!message || typeof message !== "object") {
         return "";
@@ -89,30 +117,36 @@ function extractSubagentOutputText(message) {
             return sanitizeTextContent(content);
         }
         if (Array.isArray(content)) {
-            return (extractTextFromChatContent(content, {
-                sanitizeText: sanitizeTextContent,
-                normalizeText: (text) => text.trim(),
-                joinWith: "",
-            }) ?? "");
+            return extractInlineTextContent(content);
         }
         return "";
     }
     if (role === "toolResult" || role === "tool") {
         return extractToolResultText(message.content);
     }
-    if (typeof content === "string") {
-        return sanitizeTextContent(content);
-    }
-    if (Array.isArray(content)) {
-        return (extractTextFromChatContent(content, {
-            sanitizeText: sanitizeTextContent,
-            normalizeText: (text) => text.trim(),
-            joinWith: "",
-        }) ?? "");
+    if (role == null) {
+        if (typeof content === "string") {
+            return sanitizeTextContent(content);
+        }
+        if (Array.isArray(content)) {
+            return extractInlineTextContent(content);
+        }
     }
     return "";
 }
 async function readLatestSubagentOutput(sessionKey) {
+    try {
+        const latestAssistant = await readLatestAssistantReply({
+            sessionKey,
+            limit: 50,
+        });
+        if (latestAssistant?.trim()) {
+            return latestAssistant;
+        }
+    }
+    catch {
+        // Best-effort: fall back to richer history parsing below.
+    }
     const history = await callGateway({
         method: "chat.history",
         params: { sessionKey, limit: 50 },
@@ -140,6 +174,26 @@ async function readLatestSubagentOutputWithRetry(params) {
     }
     return result;
 }
+async function waitForSubagentOutputChange(params) {
+    const baseline = params.baselineReply.trim();
+    if (!baseline) {
+        return params.baselineReply;
+    }
+    const RETRY_INTERVAL_MS = 100;
+    const deadline = Date.now() + Math.max(0, Math.min(params.maxWaitMs, 5_000));
+    let latest = params.baselineReply;
+    while (Date.now() < deadline) {
+        const next = await readLatestSubagentOutput(params.sessionKey);
+        if (next?.trim()) {
+            latest = next;
+            if (next.trim() !== baseline) {
+                return next;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+    }
+    return latest;
+}
 function formatDurationShort(valueMs) {
     if (!valueMs || !Number.isFinite(valueMs) || valueMs <= 0) {
         return "n/a";
@@ -197,7 +251,7 @@ async function buildCompactAnnounceStatsLine(params) {
     if (typeof promptCache === "number" && promptCache > ioTotal) {
         parts.push(`prompt/cache ${formatTokenCount(promptCache)}`);
     }
-    return `Stats: ${parts.join(" • ")}`;
+    return `Stats: ${parts.join(" \u00b7 ")}`;
 }
 function resolveAnnounceOrigin(entry, requesterOrigin) {
     const normalizedRequester = normalizeDeliveryContext(requesterOrigin);
@@ -213,7 +267,100 @@ function resolveAnnounceOrigin(entry, requesterOrigin) {
     // requesterOrigin (captured at spawn time) reflects the channel the user is
     // actually on and must take priority over the session entry, which may carry
     // stale lastChannel / lastTo values from a previous channel interaction.
-    return mergeDeliveryContext(normalizedRequester, normalizedEntry);
+    const entryForMerge = normalizedRequester?.to &&
+        normalizedRequester.threadId == null &&
+        normalizedEntry?.threadId != null
+        ? (() => {
+            const { threadId: _ignore, ...rest } = normalizedEntry;
+            return rest;
+        })()
+        : normalizedEntry;
+    return mergeDeliveryContext(normalizedRequester, entryForMerge);
+}
+async function resolveSubagentCompletionOrigin(params) {
+    const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
+    const requesterConversation = (() => {
+        const channel = requesterOrigin?.channel?.trim().toLowerCase();
+        const to = requesterOrigin?.to?.trim();
+        const accountId = normalizeAccountId(requesterOrigin?.accountId);
+        const threadId = requesterOrigin?.threadId != null && requesterOrigin.threadId !== ""
+            ? String(requesterOrigin.threadId).trim()
+            : undefined;
+        const conversationId = threadId || (to?.startsWith("channel:") ? to.slice("channel:".length) : "");
+        if (!channel || !conversationId) {
+            return undefined;
+        }
+        const ref = {
+            channel,
+            accountId,
+            conversationId,
+        };
+        return ref;
+    })();
+    const route = createBoundDeliveryRouter().resolveDestination({
+        eventKind: "task_completion",
+        targetSessionKey: params.childSessionKey,
+        requester: requesterConversation,
+        failClosed: false,
+    });
+    if (route.mode === "bound" && route.binding) {
+        const boundOrigin = {
+            channel: route.binding.conversation.channel,
+            accountId: route.binding.conversation.accountId,
+            to: `channel:${route.binding.conversation.conversationId}`,
+            threadId: route.binding.conversation.conversationId,
+        };
+        return {
+            // Bound target is authoritative; requester hints fill only missing fields.
+            origin: mergeDeliveryContext(boundOrigin, requesterOrigin),
+            routeMode: "bound",
+        };
+    }
+    const hookRunner = getGlobalHookRunner();
+    if (!hookRunner?.hasHooks("subagent_delivery_target")) {
+        return {
+            origin: requesterOrigin,
+            routeMode: "fallback",
+        };
+    }
+    try {
+        const result = await hookRunner.runSubagentDeliveryTarget({
+            childSessionKey: params.childSessionKey,
+            requesterSessionKey: params.requesterSessionKey,
+            requesterOrigin,
+            childRunId: params.childRunId,
+            spawnMode: params.spawnMode,
+            expectsCompletionMessage: params.expectsCompletionMessage,
+        }, {
+            runId: params.childRunId,
+            childSessionKey: params.childSessionKey,
+            requesterSessionKey: params.requesterSessionKey,
+        });
+        const hookOrigin = normalizeDeliveryContext(result?.origin);
+        if (!hookOrigin) {
+            return {
+                origin: requesterOrigin,
+                routeMode: "fallback",
+            };
+        }
+        if (hookOrigin.channel && !isDeliverableMessageChannel(hookOrigin.channel)) {
+            return {
+                origin: requesterOrigin,
+                routeMode: "fallback",
+            };
+        }
+        // Hook-provided origin should override requester defaults when present.
+        return {
+            origin: mergeDeliveryContext(hookOrigin, requesterOrigin),
+            routeMode: "hook",
+        };
+    }
+    catch {
+        return {
+            origin: requesterOrigin,
+            routeMode: "fallback",
+        };
+    }
 }
 async function sendAnnounce(item) {
     const requesterDepth = getSubagentDepthFromSessionStore(item.sessionKey);
@@ -346,26 +493,46 @@ async function sendSubagentAnnounceDirectly(params) {
         if (params.expectsCompletionMessage &&
             hasCompletionDirectTarget &&
             params.completionMessage?.trim()) {
-            const completionThreadId = completionDirectOrigin?.threadId != null && completionDirectOrigin.threadId !== ""
-                ? String(completionDirectOrigin.threadId)
-                : undefined;
-            await callGateway({
-                method: "send",
-                params: {
-                    channel: completionChannel,
-                    to: completionTo,
-                    accountId: completionDirectOrigin?.accountId,
-                    threadId: completionThreadId,
-                    sessionKey: canonicalRequesterSessionKey,
-                    message: params.completionMessage,
-                    idempotencyKey: params.directIdempotencyKey,
-                },
-                timeoutMs: 15_000,
-            });
-            return {
-                delivered: true,
-                path: "direct",
-            };
+            const forceBoundSessionDirectDelivery = params.spawnMode === "session" &&
+                (params.completionRouteMode === "bound" || params.completionRouteMode === "hook");
+            let shouldSendCompletionDirectly = true;
+            if (!forceBoundSessionDirectDelivery) {
+                let activeDescendantRuns = 0;
+                try {
+                    const { countActiveDescendantRuns } = await import("./subagent-registry.js");
+                    activeDescendantRuns = Math.max(0, countActiveDescendantRuns(canonicalRequesterSessionKey));
+                }
+                catch {
+                    // Best-effort only; when unavailable keep historical direct-send behavior.
+                }
+                // Keep non-bound completion announcements coordinated via requester
+                // session routing while sibling/descendant runs are still active.
+                if (activeDescendantRuns > 0) {
+                    shouldSendCompletionDirectly = false;
+                }
+            }
+            if (shouldSendCompletionDirectly) {
+                const completionThreadId = completionDirectOrigin?.threadId != null && completionDirectOrigin.threadId !== ""
+                    ? String(completionDirectOrigin.threadId)
+                    : undefined;
+                await callGateway({
+                    method: "send",
+                    params: {
+                        channel: completionChannel,
+                        to: completionTo,
+                        accountId: completionDirectOrigin?.accountId,
+                        threadId: completionThreadId,
+                        sessionKey: canonicalRequesterSessionKey,
+                        message: params.completionMessage,
+                        idempotencyKey: params.directIdempotencyKey,
+                    },
+                    timeoutMs: 15_000,
+                });
+                return {
+                    delivered: true,
+                    path: "direct",
+                };
+            }
         }
         const directOrigin = normalizeDeliveryContext(params.directOrigin);
         const threadId = directOrigin?.threadId != null && directOrigin.threadId !== ""
@@ -423,6 +590,8 @@ async function deliverSubagentAnnouncement(params) {
         completionMessage: params.completionMessage,
         directIdempotencyKey: params.directIdempotencyKey,
         completionDirectOrigin: params.completionDirectOrigin,
+        completionRouteMode: params.completionRouteMode,
+        spawnMode: params.spawnMode,
         directOrigin: params.directOrigin,
         requesterIsSubagent: params.requesterIsSubagent,
         expectsCompletionMessage: params.expectsCompletionMessage,
@@ -456,7 +625,9 @@ export function buildSubagentSystemPrompt(params) {
         ? params.task.replace(/\s+/g, " ").trim()
         : "{{TASK_DESCRIPTION}}";
     const childDepth = typeof params.childDepth === "number" ? params.childDepth : 1;
-    const maxSpawnDepth = typeof params.maxSpawnDepth === "number" ? params.maxSpawnDepth : 1;
+    const maxSpawnDepth = typeof params.maxSpawnDepth === "number"
+        ? params.maxSpawnDepth
+        : DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH;
     const canSpawn = childDepth < maxSpawnDepth;
     const parentLabel = childDepth >= 2 ? "parent orchestrator" : "main agent";
     const lines = [
@@ -510,9 +681,6 @@ export function buildSubagentSystemPrompt(params) {
     return lines.join("\n");
 }
 function buildAnnounceReplyInstruction(params) {
-    if (params.expectsCompletionMessage) {
-        return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type).`;
-    }
     if (params.remainingActiveSubagentRuns > 0) {
         const activeRunsLabel = params.remainingActiveSubagentRuns === 1 ? "run" : "runs";
         return `There are still ${params.remainingActiveSubagentRuns} active subagent ${activeRunsLabel} for this session. If they are part of the same workflow, wait for the remaining results before sending a user update. If they are unrelated, respond normally using only the result above.`;
@@ -520,6 +688,9 @@ function buildAnnounceReplyInstruction(params) {
     if (params.requesterIsSubagent) {
         return `Convert this completion into a concise internal orchestration update for your parent agent in your own words. Keep this internal context private (don't mention system/log/stats/session details or announce type). If this result is duplicate or no update is needed, reply ONLY: ${SILENT_REPLY_TOKEN}.`;
     }
+    if (params.expectsCompletionMessage) {
+        return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type).`;
+    }
     return `A completed ${params.announceType} is ready for user delivery. Convert the result above into your normal assistant voice and send that user-facing update now. Keep this internal context private (don't mention system/log/stats/session details or announce type), and do not copy the system message verbatim. Reply ONLY: ${SILENT_REPLY_TOKEN} if this exact result was already delivered to the user in this same turn.`;
 }
 export async function runSubagentAnnounceFlow(params) {
@@ -540,7 +711,7 @@ export async function runSubagentAnnounceFlow(params) {
         let outcome = params.outcome;
         // Lifecycle "end" can arrive before auto-compaction retries finish. If the
         // subagent is still active, wait for the embedded run to fully settle.
-        if (!expectsCompletionMessage && childSessionId && isEmbeddedPiRunActive(childSessionId)) {
+        if (childSessionId && isEmbeddedPiRunActive(childSessionId)) {
             const settled = await waitForEmbeddedPiRunEnd(childSessionId, settleTimeoutMs);
             if (!settled && isEmbeddedPiRunActive(childSessionId)) {
                 // The child run is still active (e.g., compaction retry still in progress).
@@ -603,6 +774,7 @@ export async function runSubagentAnnounceFlow(params) {
         if (!outcome) {
             outcome = { status: "unknown" };
         }
+        let requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
         let activeChildDescendantRuns = 0;
         try {
             const { countActiveDescendantRuns } = await import("./subagent-registry.js");
@@ -611,12 +783,19 @@ export async function runSubagentAnnounceFlow(params) {
         catch {
             // Best-effort only; fall back to direct announce behavior when unavailable.
         }
-        if (!expectsCompletionMessage && activeChildDescendantRuns > 0) {
+        if (activeChildDescendantRuns > 0) {
             // The finished run still has active descendant subagents. Defer announcing
             // this run until descendants settle so we avoid posting in-progress updates.
             shouldDeleteChildSession = false;
             return false;
         }
+        if (requesterDepth >= 1 && reply?.trim()) {
+            reply = await waitForSubagentOutputChange({
+                sessionKey: params.childSessionKey,
+                baselineReply: reply,
+                maxWaitMs: Math.max(250, Math.min(params.timeoutMs, 2_000)),
+            });
+        }
         // Build status label
         const statusLabel = outcome.status === "ok"
             ? "completed successfully"
@@ -633,8 +812,7 @@ export async function runSubagentAnnounceFlow(params) {
         const findings = reply || "(no output)";
         let completionMessage = "";
         let triggerMessage = "";
-        let requesterDepth = getSubagentDepthFromSessionStore(targetRequesterSessionKey);
-        let requesterIsSubagent = !expectsCompletionMessage && requesterDepth >= 1;
+        let requesterIsSubagent = requesterDepth >= 1;
         // If the requester subagent has already finished, bubble the announce to its
         // requester (typically main) so descendant completion is not silently lost.
         // BUT: only fallback if the parent SESSION is deleted, not just if the current
@@ -691,6 +869,8 @@ export async function runSubagentAnnounceFlow(params) {
         completionMessage = buildCompletionDeliveryMessage({
             findings,
             subagentName,
+            spawnMode: params.spawnMode,
+            outcome,
         });
         const internalSummaryMessage = [
             `[System Message] [sessionId: ${announceSessionId}] A ${announceType} "${taskLabel}" just ${statusLabel}.`,
@@ -712,6 +892,20 @@ export async function runSubagentAnnounceFlow(params) {
             const { entry } = loadRequesterSessionEntry(targetRequesterSessionKey);
             directOrigin = resolveAnnounceOrigin(entry, targetRequesterOrigin);
         }
+        const completionResolution = expectsCompletionMessage && !requesterIsSubagent
+            ? await resolveSubagentCompletionOrigin({
+                childSessionKey: params.childSessionKey,
+                requesterSessionKey: targetRequesterSessionKey,
+                requesterOrigin: directOrigin,
+                childRunId: params.childRunId,
+                spawnMode: params.spawnMode,
+                expectsCompletionMessage,
+            })
+            : {
+                origin: targetRequesterOrigin,
+                routeMode: "fallback",
+            };
+        const completionDirectOrigin = completionResolution.origin;
         // Use a deterministic idempotency key so the gateway dedup cache
         // catches duplicates if this announce is also queued by the gateway-
         // level message queue while the main session is busy (#17122).
@@ -722,12 +916,16 @@ export async function runSubagentAnnounceFlow(params) {
             triggerMessage,
             completionMessage,
             summaryLine: taskLabel,
-            requesterOrigin: targetRequesterOrigin,
-            completionDirectOrigin: targetRequesterOrigin,
+            requesterOrigin: expectsCompletionMessage && !requesterIsSubagent
+                ? completionDirectOrigin
+                : targetRequesterOrigin,
+            completionDirectOrigin,
             directOrigin,
             targetRequesterSessionKey,
             requesterIsSubagent,
             expectsCompletionMessage: expectsCompletionMessage,
+            completionRouteMode: completionResolution.routeMode,
+            spawnMode: params.spawnMode,
             directIdempotencyKey,
         });
         didAnnounce = delivery.delivered;
@@ -757,7 +955,11 @@ export async function runSubagentAnnounceFlow(params) {
             try {
                 await callGateway({
                     method: "sessions.delete",
-                    params: { key: params.childSessionKey, deleteTranscript: true },
+                    params: {
+                        key: params.childSessionKey,
+                        deleteTranscript: true,
+                        emitLifecycleHooks: false,
+                    },
                     timeoutMs: 10_000,
                 });
             }

package/dist/agents/subagent-lifecycle-events.js

@@ -0,0 +1,19 @@
+export const SUBAGENT_TARGET_KIND_SUBAGENT = "subagent";
+export const SUBAGENT_TARGET_KIND_ACP = "acp";
+export const SUBAGENT_ENDED_REASON_COMPLETE = "subagent-complete";
+export const SUBAGENT_ENDED_REASON_ERROR = "subagent-error";
+export const SUBAGENT_ENDED_REASON_KILLED = "subagent-killed";
+export const SUBAGENT_ENDED_REASON_SESSION_RESET = "session-reset";
+export const SUBAGENT_ENDED_REASON_SESSION_DELETE = "session-delete";
+export const SUBAGENT_ENDED_OUTCOME_OK = "ok";
+export const SUBAGENT_ENDED_OUTCOME_ERROR = "error";
+export const SUBAGENT_ENDED_OUTCOME_TIMEOUT = "timeout";
+export const SUBAGENT_ENDED_OUTCOME_KILLED = "killed";
+export const SUBAGENT_ENDED_OUTCOME_RESET = "reset";
+export const SUBAGENT_ENDED_OUTCOME_DELETED = "deleted";
+export function resolveSubagentSessionEndedOutcome(reason) {
+    if (reason === SUBAGENT_ENDED_REASON_SESSION_RESET) {
+        return SUBAGENT_ENDED_OUTCOME_RESET;
+    }
+    return SUBAGENT_ENDED_OUTCOME_DELETED;
+}

package/dist/agents/subagent-registry-cleanup.js

@@ -0,0 +1,31 @@
+import { SUBAGENT_ENDED_REASON_COMPLETE, } from "./subagent-lifecycle-events.js";
+export function resolveCleanupCompletionReason(entry) {
+    return entry.endedReason ?? SUBAGENT_ENDED_REASON_COMPLETE;
+}
+function resolveEndedAgoMs(entry, now) {
+    return typeof entry.endedAt === "number" ? now - entry.endedAt : 0;
+}
+export function resolveDeferredCleanupDecision(params) {
+    const endedAgo = resolveEndedAgoMs(params.entry, params.now);
+    if (params.entry.expectsCompletionMessage === true && params.activeDescendantRuns > 0) {
+        if (endedAgo > params.announceExpiryMs) {
+            return { kind: "give-up", reason: "expiry" };
+        }
+        return { kind: "defer-descendants", delayMs: params.deferDescendantDelayMs };
+    }
+    const retryCount = (params.entry.announceRetryCount ?? 0) + 1;
+    if (retryCount >= params.maxAnnounceRetryCount || endedAgo > params.announceExpiryMs) {
+        return {
+            kind: "give-up",
+            reason: retryCount >= params.maxAnnounceRetryCount ? "retry-limit" : "expiry",
+            retryCount,
+        };
+    }
+    return {
+        kind: "retry",
+        retryCount,
+        resumeDelayMs: params.entry.expectsCompletionMessage === true
+            ? params.resolveAnnounceRetryDelayMs(retryCount)
+            : undefined,
+    };
+}

package/dist/agents/subagent-registry-completion.js

@@ -0,0 +1,68 @@
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
+import { SUBAGENT_ENDED_OUTCOME_ERROR, SUBAGENT_ENDED_OUTCOME_OK, SUBAGENT_ENDED_OUTCOME_TIMEOUT, SUBAGENT_TARGET_KIND_SUBAGENT, } from "./subagent-lifecycle-events.js";
+export function runOutcomesEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    if (a.status !== b.status) {
+        return false;
+    }
+    if (a.status === "error" && b.status === "error") {
+        return (a.error ?? "") === (b.error ?? "");
+    }
+    return true;
+}
+export function resolveLifecycleOutcomeFromRunOutcome(outcome) {
+    if (outcome?.status === "error") {
+        return SUBAGENT_ENDED_OUTCOME_ERROR;
+    }
+    if (outcome?.status === "timeout") {
+        return SUBAGENT_ENDED_OUTCOME_TIMEOUT;
+    }
+    return SUBAGENT_ENDED_OUTCOME_OK;
+}
+export async function emitSubagentEndedHookOnce(params) {
+    const runId = params.entry.runId.trim();
+    if (!runId) {
+        return false;
+    }
+    if (params.entry.endedHookEmittedAt) {
+        return false;
+    }
+    if (params.inFlightRunIds.has(runId)) {
+        return false;
+    }
+    params.inFlightRunIds.add(runId);
+    try {
+        const hookRunner = getGlobalHookRunner();
+        if (hookRunner?.hasHooks("subagent_ended")) {
+            await hookRunner.runSubagentEnded({
+                targetSessionKey: params.entry.childSessionKey,
+                targetKind: SUBAGENT_TARGET_KIND_SUBAGENT,
+                reason: params.reason,
+                sendFarewell: params.sendFarewell,
+                accountId: params.accountId,
+                runId: params.entry.runId,
+                endedAt: params.entry.endedAt,
+                outcome: params.outcome,
+                error: params.error,
+            }, {
+                runId: params.entry.runId,
+                childSessionKey: params.entry.childSessionKey,
+                requesterSessionKey: params.entry.requesterSessionKey,
+            });
+        }
+        params.entry.endedHookEmittedAt = Date.now();
+        params.persist();
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        params.inFlightRunIds.delete(runId);
+    }
+}