@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/agents/subagent-registry.js

@@ -2,6 +2,7 @@ import { loadConfig } from "../config/config.js";
 import { callGateway } from "../gateway/call.js";
 import { onAgentEvent } from "../infra/agent-events.js";
 import { normalizeDeliveryContext } from "../utils/delivery-context.js";
+import { resetAnnounceQueuesForTests } from "./subagent-announce-queue.js";
 import { runSubagentAnnounceFlow } from "./subagent-announce.js";
 import { loadSubagentRegistryFromDisk, saveSubagentRegistryToDisk, } from "./subagent-registry.store.js";
 import { resolveAgentTimeoutMs } from "./timeout.js";
@@ -11,6 +12,19 @@ let listenerStarted = false;
 let listenerStop = null;
 // Use var to avoid TDZ when init runs across circular imports during bootstrap.
 var restoreAttempted = false;
+const SUBAGENT_ANNOUNCE_TIMEOUT_MS = 120_000;
+/**
+ * Maximum number of announce delivery attempts before giving up.
+ * Prevents infinite retry loops when `runSubagentAnnounceFlow` repeatedly
+ * returns `false` due to stale state or transient conditions (#18264).
+ */
+const MAX_ANNOUNCE_RETRY_COUNT = 3;
+/**
+ * Announce entries older than this are force-expired even if delivery never
+ * succeeded. Guards against stale registry entries surviving gateway restarts.
+ */
+const ANNOUNCE_EXPIRY_MS = 5 * 60_000; // 5 minutes
+// (Backoff constant removed — max-retry + expiry guards are sufficient.)
 function persistSubagentRuns() {
     try {
         saveSubagentRegistryToDisk(subagentRuns);
@@ -20,55 +34,86 @@ function persistSubagentRuns() {
     }
 }
 const resumedRuns = new Set();
+function suppressAnnounceForSteerRestart(entry) {
+    return entry?.suppressAnnounceReason === "steer-restart";
+}
+function startSubagentAnnounceCleanupFlow(runId, entry) {
+    if (!beginSubagentCleanup(runId)) {
+        return false;
+    }
+    const requesterOrigin = normalizeDeliveryContext(entry.requesterOrigin);
+    void runSubagentAnnounceFlow({
+        childSessionKey: entry.childSessionKey,
+        childRunId: entry.runId,
+        requesterSessionKey: entry.requesterSessionKey,
+        requesterOrigin,
+        requesterDisplayKey: entry.requesterDisplayKey,
+        task: entry.task,
+        timeoutMs: SUBAGENT_ANNOUNCE_TIMEOUT_MS,
+        cleanup: entry.cleanup,
+        waitForCompletion: false,
+        startedAt: entry.startedAt,
+        endedAt: entry.endedAt,
+        label: entry.label,
+        outcome: entry.outcome,
+    }).then((didAnnounce) => {
+        finalizeSubagentCleanup(runId, entry.cleanup, didAnnounce);
+    });
+    return true;
+}
 function resumeSubagentRun(runId) {
-    if (!runId || resumedRuns.has(runId))
+    if (!runId || resumedRuns.has(runId)) {
         return;
+    }
     const entry = subagentRuns.get(runId);
-    if (!entry)
+    if (!entry) {
+        return;
+    }
+    if (entry.cleanupCompletedAt) {
+        return;
+    }
+    // Skip entries that have exhausted their retry budget or expired (#18264).
+    if ((entry.announceRetryCount ?? 0) >= MAX_ANNOUNCE_RETRY_COUNT) {
+        entry.cleanupCompletedAt = Date.now();
+        persistSubagentRuns();
         return;
-    if (entry.cleanupCompletedAt)
+    }
+    if (typeof entry.endedAt === "number" && Date.now() - entry.endedAt > ANNOUNCE_EXPIRY_MS) {
+        entry.cleanupCompletedAt = Date.now();
+        persistSubagentRuns();
         return;
+    }
     if (typeof entry.endedAt === "number" && entry.endedAt > 0) {
-        if (!beginSubagentCleanup(runId))
+        if (suppressAnnounceForSteerRestart(entry)) {
+            resumedRuns.add(runId);
             return;
-        const requesterOrigin = normalizeDeliveryContext(entry.requesterOrigin);
-        void runSubagentAnnounceFlow({
-            childSessionKey: entry.childSessionKey,
-            childRunId: entry.runId,
-            requesterSessionKey: entry.requesterSessionKey,
-            requesterOrigin,
-            requesterDisplayKey: entry.requesterDisplayKey,
-            task: entry.task,
-            timeoutMs: 30_000,
-            cleanup: entry.cleanup,
-            waitForCompletion: false,
-            startedAt: entry.startedAt,
-            endedAt: entry.endedAt,
-            label: entry.label,
-            outcome: entry.outcome,
-        }).then((didAnnounce) => {
-            finalizeSubagentCleanup(runId, entry.cleanup, didAnnounce);
-        });
+        }
+        if (!startSubagentAnnounceCleanupFlow(runId, entry)) {
+            return;
+        }
         resumedRuns.add(runId);
         return;
     }
     // Wait for completion again after restart.
     const cfg = loadConfig();
-    const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, undefined);
+    const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, entry.runTimeoutSeconds);
     void waitForSubagentCompletion(runId, waitTimeoutMs);
     resumedRuns.add(runId);
 }
 function restoreSubagentRunsOnce() {
-    if (restoreAttempted)
+    if (restoreAttempted) {
         return;
+    }
     restoreAttempted = true;
     try {
         const restored = loadSubagentRegistryFromDisk();
-        if (restored.size === 0)
+        if (restored.size === 0) {
             return;
+        }
         for (const [runId, entry] of restored.entries()) {
-            if (!runId || !entry)
+            if (!runId || !entry) {
                 continue;
+            }
             // Keep any newer in-memory entries.
             if (!subagentRuns.has(runId)) {
                 subagentRuns.set(runId, entry);
@@ -90,24 +135,27 @@ function restoreSubagentRunsOnce() {
 function resolveArchiveAfterMs(cfg) {
     const config = cfg ?? loadConfig();
     const minutes = config.agents?.defaults?.subagents?.archiveAfterMinutes ?? 60;
-    if (!Number.isFinite(minutes) || minutes <= 0)
+    if (!Number.isFinite(minutes) || minutes <= 0) {
         return undefined;
+    }
     return Math.max(1, Math.floor(minutes)) * 60_000;
 }
 function resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds) {
-    return resolveAgentTimeoutMs({ cfg, overrideSeconds: runTimeoutSeconds });
+    return resolveAgentTimeoutMs({ cfg, overrideSeconds: runTimeoutSeconds ?? 0 });
 }
 function startSweeper() {
-    if (sweeper)
+    if (sweeper) {
         return;
+    }
     sweeper = setInterval(() => {
         void sweepSubagentRuns();
     }, 60_000);
     sweeper.unref?.();
 }
 function stopSweeper() {
-    if (!sweeper)
+    if (!sweeper) {
         return;
+    }
     clearInterval(sweeper);
     sweeper = null;
 }
@@ -115,8 +163,9 @@ async function sweepSubagentRuns() {
     const now = Date.now();
     let mutated = false;
     for (const [runId, entry] of subagentRuns.entries()) {
-        if (!entry.archiveAtMs || entry.archiveAtMs > now)
+        if (!entry.archiveAtMs || entry.archiveAtMs > now) {
             continue;
+        }
         subagentRuns.delete(runId);
         mutated = true;
         try {
@@ -130,10 +179,12 @@ async function sweepSubagentRuns() {
             // ignore
         }
     }
-    if (mutated)
+    if (mutated) {
         persistSubagentRuns();
-    if (subagentRuns.size === 0)
+    }
+    if (subagentRuns.size === 0) {
         stopSweeper();
+    }
 }
 function ensureListener() {
     if (listenerStarted) {
@@ -141,8 +192,9 @@ function ensureListener() {
     }
     listenerStarted = true;
     listenerStop = onAgentEvent((evt) => {
-        if (!evt || evt.stream !== "lifecycle")
+        if (!evt || evt.stream !== "lifecycle") {
             return;
+        }
         const entry = subagentRuns.get(evt.runId);
         if (!entry) {
             return;
@@ -156,77 +208,194 @@ function ensureListener() {
             }
             return;
         }
-        if (phase !== "end" && phase !== "error")
+        if (phase !== "end" && phase !== "error") {
             return;
+        }
         const endedAt = typeof evt.data?.endedAt === "number" ? evt.data.endedAt : Date.now();
         entry.endedAt = endedAt;
         if (phase === "error") {
             const error = typeof evt.data?.error === "string" ? evt.data.error : undefined;
             entry.outcome = { status: "error", error };
         }
+        else if (evt.data?.aborted) {
+            entry.outcome = { status: "timeout" };
+        }
         else {
             entry.outcome = { status: "ok" };
         }
         persistSubagentRuns();
-        if (!beginSubagentCleanup(evt.runId)) {
+        if (suppressAnnounceForSteerRestart(entry)) {
+            return;
+        }
+        if (!startSubagentAnnounceCleanupFlow(evt.runId, entry)) {
             return;
         }
-        const requesterOrigin = normalizeDeliveryContext(entry.requesterOrigin);
-        void runSubagentAnnounceFlow({
-            childSessionKey: entry.childSessionKey,
-            childRunId: entry.runId,
-            requesterSessionKey: entry.requesterSessionKey,
-            requesterOrigin,
-            requesterDisplayKey: entry.requesterDisplayKey,
-            task: entry.task,
-            timeoutMs: 30_000,
-            cleanup: entry.cleanup,
-            waitForCompletion: false,
-            startedAt: entry.startedAt,
-            endedAt: entry.endedAt,
-            label: entry.label,
-            outcome: entry.outcome,
-        }).then((didAnnounce) => {
-            finalizeSubagentCleanup(evt.runId, entry.cleanup, didAnnounce);
-        });
     });
 }
 function finalizeSubagentCleanup(runId, cleanup, didAnnounce) {
     const entry = subagentRuns.get(runId);
-    if (!entry)
-        return;
-    if (cleanup === "delete") {
-        subagentRuns.delete(runId);
-        persistSubagentRuns();
+    if (!entry) {
         return;
     }
     if (!didAnnounce) {
-        // Allow retry on the next wake if the announce failed.
+        const retryCount = (entry.announceRetryCount ?? 0) + 1;
+        entry.announceRetryCount = retryCount;
+        entry.lastAnnounceRetryAt = Date.now();
+        // Check if the announce has exceeded retry limits or expired (#18264).
+        const endedAgo = typeof entry.endedAt === "number" ? Date.now() - entry.endedAt : 0;
+        if (retryCount >= MAX_ANNOUNCE_RETRY_COUNT || endedAgo > ANNOUNCE_EXPIRY_MS) {
+            // Give up: mark as completed to break the infinite retry loop.
+            entry.cleanupCompletedAt = Date.now();
+            persistSubagentRuns();
+            retryDeferredCompletedAnnounces(runId);
+            return;
+        }
+        // Allow retry on the next wake if announce was deferred or failed.
         entry.cleanupHandled = false;
+        resumedRuns.delete(runId);
         persistSubagentRuns();
         return;
     }
+    if (cleanup === "delete") {
+        subagentRuns.delete(runId);
+        persistSubagentRuns();
+        retryDeferredCompletedAnnounces(runId);
+        return;
+    }
     entry.cleanupCompletedAt = Date.now();
     persistSubagentRuns();
+    retryDeferredCompletedAnnounces(runId);
+}
+function retryDeferredCompletedAnnounces(excludeRunId) {
+    const now = Date.now();
+    for (const [runId, entry] of subagentRuns.entries()) {
+        if (excludeRunId && runId === excludeRunId) {
+            continue;
+        }
+        if (typeof entry.endedAt !== "number") {
+            continue;
+        }
+        if (entry.cleanupCompletedAt || entry.cleanupHandled) {
+            continue;
+        }
+        if (suppressAnnounceForSteerRestart(entry)) {
+            continue;
+        }
+        // Force-expire announces that have been pending too long (#18264).
+        const endedAgo = now - (entry.endedAt ?? now);
+        if (endedAgo > ANNOUNCE_EXPIRY_MS) {
+            entry.cleanupCompletedAt = now;
+            persistSubagentRuns();
+            continue;
+        }
+        resumedRuns.delete(runId);
+        resumeSubagentRun(runId);
+    }
 }
 function beginSubagentCleanup(runId) {
     const entry = subagentRuns.get(runId);
-    if (!entry)
+    if (!entry) {
         return false;
-    if (entry.cleanupCompletedAt)
+    }
+    if (entry.cleanupCompletedAt) {
         return false;
-    if (entry.cleanupHandled)
+    }
+    if (entry.cleanupHandled) {
         return false;
+    }
     entry.cleanupHandled = true;
     persistSubagentRuns();
     return true;
 }
+export function markSubagentRunForSteerRestart(runId) {
+    const key = runId.trim();
+    if (!key) {
+        return false;
+    }
+    const entry = subagentRuns.get(key);
+    if (!entry) {
+        return false;
+    }
+    if (entry.suppressAnnounceReason === "steer-restart") {
+        return true;
+    }
+    entry.suppressAnnounceReason = "steer-restart";
+    persistSubagentRuns();
+    return true;
+}
+export function clearSubagentRunSteerRestart(runId) {
+    const key = runId.trim();
+    if (!key) {
+        return false;
+    }
+    const entry = subagentRuns.get(key);
+    if (!entry) {
+        return false;
+    }
+    if (entry.suppressAnnounceReason !== "steer-restart") {
+        return true;
+    }
+    entry.suppressAnnounceReason = undefined;
+    persistSubagentRuns();
+    // If the interrupted run already finished while suppression was active, retry
+    // cleanup now so completion output is not lost when restart dispatch fails.
+    resumedRuns.delete(key);
+    if (typeof entry.endedAt === "number" && !entry.cleanupCompletedAt) {
+        resumeSubagentRun(key);
+    }
+    return true;
+}
+export function replaceSubagentRunAfterSteer(params) {
+    const previousRunId = params.previousRunId.trim();
+    const nextRunId = params.nextRunId.trim();
+    if (!previousRunId || !nextRunId) {
+        return false;
+    }
+    const previous = subagentRuns.get(previousRunId);
+    const source = previous ?? params.fallback;
+    if (!source) {
+        return false;
+    }
+    if (previousRunId !== nextRunId) {
+        subagentRuns.delete(previousRunId);
+        resumedRuns.delete(previousRunId);
+    }
+    const now = Date.now();
+    const cfg = loadConfig();
+    const archiveAfterMs = resolveArchiveAfterMs(cfg);
+    const archiveAtMs = archiveAfterMs ? now + archiveAfterMs : undefined;
+    const runTimeoutSeconds = params.runTimeoutSeconds ?? source.runTimeoutSeconds ?? 0;
+    const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds);
+    const next = {
+        ...source,
+        runId: nextRunId,
+        startedAt: now,
+        endedAt: undefined,
+        outcome: undefined,
+        cleanupCompletedAt: undefined,
+        cleanupHandled: false,
+        suppressAnnounceReason: undefined,
+        announceRetryCount: undefined,
+        lastAnnounceRetryAt: undefined,
+        archiveAtMs,
+        runTimeoutSeconds,
+    };
+    subagentRuns.set(nextRunId, next);
+    ensureListener();
+    persistSubagentRuns();
+    if (archiveAtMs) {
+        startSweeper();
+    }
+    void waitForSubagentCompletion(nextRunId, waitTimeoutMs);
+    return true;
+}
 export function registerSubagentRun(params) {
     const now = Date.now();
     const cfg = loadConfig();
     const archiveAfterMs = resolveArchiveAfterMs(cfg);
     const archiveAtMs = archiveAfterMs ? now + archiveAfterMs : undefined;
-    const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, params.runTimeoutSeconds);
+    const runTimeoutSeconds = params.runTimeoutSeconds ?? 0;
+    const waitTimeoutMs = resolveSubagentWaitTimeoutMs(cfg, runTimeoutSeconds);
     const requesterOrigin = normalizeDeliveryContext(params.requesterOrigin);
     subagentRuns.set(params.runId, {
         runId: params.runId,
@@ -237,6 +406,8 @@ export function registerSubagentRun(params) {
         task: params.task,
         cleanup: params.cleanup,
         label: params.label,
+        model: params.model,
+        runTimeoutSeconds,
         createdAt: now,
         startedAt: now,
         archiveAtMs,
@@ -244,8 +415,9 @@ export function registerSubagentRun(params) {
     });
     ensureListener();
     persistSubagentRuns();
-    if (archiveAfterMs)
+    if (archiveAfterMs) {
         startSweeper();
+    }
     // Wait for subagent completion via gateway RPC (cross-process).
     // The in-process lifecycle listener is a fallback for embedded runs.
     void waitForSubagentCompletion(params.runId, waitTimeoutMs);
@@ -253,19 +425,21 @@ export function registerSubagentRun(params) {
 async function waitForSubagentCompletion(runId, waitTimeoutMs) {
     try {
         const timeoutMs = Math.max(1, Math.floor(waitTimeoutMs));
-        const wait = (await callGateway({
+        const wait = await callGateway({
             method: "agent.wait",
             params: {
                 runId,
                 timeoutMs,
             },
             timeoutMs: timeoutMs + 10_000,
-        }));
-        if (wait?.status !== "ok" && wait?.status !== "error")
+        });
+        if (wait?.status !== "ok" && wait?.status !== "error" && wait?.status !== "timeout") {
             return;
+        }
         const entry = subagentRuns.get(runId);
-        if (!entry)
+        if (!entry) {
             return;
+        }
         let mutated = false;
         if (typeof wait.startedAt === "number") {
             entry.startedAt = wait.startedAt;
@@ -279,39 +453,32 @@ async function waitForSubagentCompletion(runId, waitTimeoutMs) {
             entry.endedAt = Date.now();
             mutated = true;
         }
+        const waitError = typeof wait.error === "string" ? wait.error : undefined;
         entry.outcome =
-            wait.status === "error" ? { status: "error", error: wait.error } : { status: "ok" };
+            wait.status === "error"
+                ? { status: "error", error: waitError }
+                : wait.status === "timeout"
+                    ? { status: "timeout" }
+                    : { status: "ok" };
         mutated = true;
-        if (mutated)
+        if (mutated) {
             persistSubagentRuns();
-        if (!beginSubagentCleanup(runId))
+        }
+        if (suppressAnnounceForSteerRestart(entry)) {
             return;
-        const requesterOrigin = normalizeDeliveryContext(entry.requesterOrigin);
-        void runSubagentAnnounceFlow({
-            childSessionKey: entry.childSessionKey,
-            childRunId: entry.runId,
-            requesterSessionKey: entry.requesterSessionKey,
-            requesterOrigin,
-            requesterDisplayKey: entry.requesterDisplayKey,
-            task: entry.task,
-            timeoutMs: 30_000,
-            cleanup: entry.cleanup,
-            waitForCompletion: false,
-            startedAt: entry.startedAt,
-            endedAt: entry.endedAt,
-            label: entry.label,
-            outcome: entry.outcome,
-        }).then((didAnnounce) => {
-            finalizeSubagentCleanup(runId, entry.cleanup, didAnnounce);
-        });
+        }
+        if (!startSubagentAnnounceCleanupFlow(runId, entry)) {
+            return;
+        }
     }
     catch {
         // ignore
     }
 }
-export function resetSubagentRegistryForTests() {
+export function resetSubagentRegistryForTests(opts) {
     subagentRuns.clear();
     resumedRuns.clear();
+    resetAnnounceQueuesForTests();
     stopSweeper();
     restoreAttempted = false;
     if (listenerStop) {
@@ -319,25 +486,210 @@ export function resetSubagentRegistryForTests() {
         listenerStop = null;
     }
     listenerStarted = false;
-    persistSubagentRuns();
+    if (opts?.persist !== false) {
+        persistSubagentRuns();
+    }
 }
 export function addSubagentRunForTests(entry) {
     subagentRuns.set(entry.runId, entry);
-    persistSubagentRuns();
 }
 export function releaseSubagentRun(runId) {
     const didDelete = subagentRuns.delete(runId);
-    if (didDelete)
+    if (didDelete) {
         persistSubagentRuns();
-    if (subagentRuns.size === 0)
+    }
+    if (subagentRuns.size === 0) {
         stopSweeper();
+    }
+}
+function findRunIdsByChildSessionKey(childSessionKey) {
+    const key = childSessionKey.trim();
+    if (!key) {
+        return [];
+    }
+    const runIds = [];
+    for (const [runId, entry] of subagentRuns.entries()) {
+        if (entry.childSessionKey === key) {
+            runIds.push(runId);
+        }
+    }
+    return runIds;
+}
+function getRunsSnapshotForRead() {
+    const merged = new Map();
+    const shouldReadDisk = !(process.env.VITEST || process.env.NODE_ENV === "test");
+    if (shouldReadDisk) {
+        try {
+            // Registry state is persisted to disk so other worker processes (for
+            // example cron runners) can observe active children spawned elsewhere.
+            for (const [runId, entry] of loadSubagentRegistryFromDisk().entries()) {
+                merged.set(runId, entry);
+            }
+        }
+        catch {
+            // Ignore disk read failures and fall back to local memory state.
+        }
+    }
+    for (const [runId, entry] of subagentRuns.entries()) {
+        merged.set(runId, entry);
+    }
+    return merged;
+}
+export function resolveRequesterForChildSession(childSessionKey) {
+    const key = childSessionKey.trim();
+    if (!key) {
+        return null;
+    }
+    let best;
+    for (const entry of getRunsSnapshotForRead().values()) {
+        if (entry.childSessionKey !== key) {
+            continue;
+        }
+        if (!best || entry.createdAt > best.createdAt) {
+            best = entry;
+        }
+    }
+    if (!best) {
+        return null;
+    }
+    return {
+        requesterSessionKey: best.requesterSessionKey,
+        requesterOrigin: normalizeDeliveryContext(best.requesterOrigin),
+    };
+}
+export function isSubagentSessionRunActive(childSessionKey) {
+    const runIds = findRunIdsByChildSessionKey(childSessionKey);
+    for (const runId of runIds) {
+        const entry = subagentRuns.get(runId);
+        if (!entry) {
+            continue;
+        }
+        if (typeof entry.endedAt !== "number") {
+            return true;
+        }
+    }
+    return false;
+}
+export function markSubagentRunTerminated(params) {
+    const runIds = new Set();
+    if (typeof params.runId === "string" && params.runId.trim()) {
+        runIds.add(params.runId.trim());
+    }
+    if (typeof params.childSessionKey === "string" && params.childSessionKey.trim()) {
+        for (const runId of findRunIdsByChildSessionKey(params.childSessionKey)) {
+            runIds.add(runId);
+        }
+    }
+    if (runIds.size === 0) {
+        return 0;
+    }
+    const now = Date.now();
+    const reason = params.reason?.trim() || "killed";
+    let updated = 0;
+    for (const runId of runIds) {
+        const entry = subagentRuns.get(runId);
+        if (!entry) {
+            continue;
+        }
+        if (typeof entry.endedAt === "number") {
+            continue;
+        }
+        entry.endedAt = now;
+        entry.outcome = { status: "error", error: reason };
+        entry.cleanupHandled = true;
+        entry.cleanupCompletedAt = now;
+        entry.suppressAnnounceReason = "killed";
+        updated += 1;
+    }
+    if (updated > 0) {
+        persistSubagentRuns();
+    }
+    return updated;
 }
 export function listSubagentRunsForRequester(requesterSessionKey) {
     const key = requesterSessionKey.trim();
-    if (!key)
+    if (!key) {
         return [];
+    }
     return [...subagentRuns.values()].filter((entry) => entry.requesterSessionKey === key);
 }
+export function countActiveRunsForSession(requesterSessionKey) {
+    const key = requesterSessionKey.trim();
+    if (!key) {
+        return 0;
+    }
+    let count = 0;
+    for (const entry of getRunsSnapshotForRead().values()) {
+        if (entry.requesterSessionKey !== key) {
+            continue;
+        }
+        if (typeof entry.endedAt === "number") {
+            continue;
+        }
+        count += 1;
+    }
+    return count;
+}
+export function countActiveDescendantRuns(rootSessionKey) {
+    const root = rootSessionKey.trim();
+    if (!root) {
+        return 0;
+    }
+    const runs = getRunsSnapshotForRead();
+    const pending = [root];
+    const visited = new Set([root]);
+    let count = 0;
+    while (pending.length > 0) {
+        const requester = pending.shift();
+        if (!requester) {
+            continue;
+        }
+        for (const entry of runs.values()) {
+            if (entry.requesterSessionKey !== requester) {
+                continue;
+            }
+            if (typeof entry.endedAt !== "number") {
+                count += 1;
+            }
+            const childKey = entry.childSessionKey.trim();
+            if (!childKey || visited.has(childKey)) {
+                continue;
+            }
+            visited.add(childKey);
+            pending.push(childKey);
+        }
+    }
+    return count;
+}
+export function listDescendantRunsForRequester(rootSessionKey) {
+    const root = rootSessionKey.trim();
+    if (!root) {
+        return [];
+    }
+    const runs = getRunsSnapshotForRead();
+    const pending = [root];
+    const visited = new Set([root]);
+    const descendants = [];
+    while (pending.length > 0) {
+        const requester = pending.shift();
+        if (!requester) {
+            continue;
+        }
+        for (const entry of runs.values()) {
+            if (entry.requesterSessionKey !== requester) {
+                continue;
+            }
+            descendants.push(entry);
+            const childKey = entry.childSessionKey.trim();
+            if (!childKey || visited.has(childKey)) {
+                continue;
+            }
+            visited.add(childKey);
+            pending.push(childKey);
+        }
+    }
+    return descendants;
+}
 export function initSubagentRegistry() {
     restoreSubagentRunsOnce();
 }