comisai 1.0.4

package/node_modules/@comis/daemon/dist/sub-agent-runner.js

@@ -0,0 +1,1224 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Sub-agent runner module.
+ * Manages async sub-agent spawning with:
+ * - Non-blocking spawn returning runId immediately
+ * - Allowlist enforcement for agent IDs
+ * - Auto-archive of completed sessions after retention period
+ * - Stats line in announcements (runtime, tokens, cost, session key)
+ * - Graceful shutdown with active run draining
+ * Extracted from daemon.ts inline session.spawn handler for testability.
+ * @module
+ */
+import { formatSessionKey, parseFormattedSessionKey, runWithContext, } from "@comis/core";
+import { suppressError } from "@comis/shared";
+import { sanitizeAssistantResponse } from "@comis/agent";
+import { randomUUID } from "node:crypto";
+import { classifyAbortReason, buildAnnouncementMessage, deliverAnnouncement, deliverFailureNotification, validateOutputs, sweepResultFiles, persistFailureRecord, } from "./sub-agent-result-processor.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Hard timeout for announceToParent calls at all call sites (300 seconds / 5 minutes).
+ *  Parent agents may call slow tools (image generation at 120s, web search, etc.)
+ *  in response to announcements. 30s caused premature fallback + duplicate delivery. */
+export const ANNOUNCE_PARENT_TIMEOUT_MS = 300_000;
+// Re-export extracted result processor types and functions for backward compatibility
+export { classifyAbortReason, buildAnnouncementMessage, deliverFailureNotification, sweepResultFiles, persistFailureRecord, validateOutputs } from "./sub-agent-result-processor.js";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createSubAgentRunner(deps) {
+    const runs = new Map();
+    const activePromises = new Set();
+    // Late-binding ref for graph coordinator (created after sub-agent runner in daemon.ts)
+    let graphCoordinatorRef;
+    /** FIFO queue per caller session key. */
+    const spawnQueue = new Map();
+    /**
+     * Count active (running) children spawned by a specific caller session.
+     * Used to enforce maxChildrenPerAgent.
+     */
+    function countActiveChildren(callerSessionKey) {
+        if (!callerSessionKey)
+            return 0;
+        let count = 0;
+        for (const run of runs.values()) {
+            if (run.status === "running" && run.callerSessionKey === callerSessionKey) {
+                count++;
+            }
+        }
+        return count;
+    }
+    // -------------------------------------------------------------------------
+    // Proxy typing stop helper (avoids repeating guard+emit in 5 paths)
+    // -------------------------------------------------------------------------
+    function emitProxyStop(run, runId, reason) {
+        if (!run.announceChannelType || !run.announceChannelId)
+            return;
+        deps.eventBus.emit("typing:proxy_stop", {
+            runId,
+            channelType: run.announceChannelType,
+            channelId: run.announceChannelId,
+            reason,
+            durationMs: (run.completedAt ?? Date.now()) - run.startedAt,
+            timestamp: Date.now(),
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Auto-archive sweep (every 5 minutes)
+    // -------------------------------------------------------------------------
+    const SWEEP_INTERVAL_MS = 300_000;
+    const MAX_RUNS = 1000;
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        const retentionMs = deps.config.subAgentRetentionMs;
+        for (const [runId, run] of runs) {
+            if ((run.status === "completed" || run.status === "failed") &&
+                run.completedAt !== undefined &&
+                now - run.completedAt > retentionMs) {
+                // Parse session key back to components for deletion
+                const parts = run.sessionKey.split(":");
+                if (parts.length >= 3) {
+                    const sessionKey = {
+                        tenantId: parts[0],
+                        userId: parts[1],
+                        channelId: parts[2],
+                    };
+                    deps.sessionStore.delete(sessionKey);
+                }
+                deps.eventBus.emit("session:sub_agent_archived", {
+                    runId,
+                    sessionKey: run.sessionKey,
+                    ageMs: now - run.completedAt,
+                    timestamp: now,
+                });
+                deps.logger?.debug({ runId, ageMs: now - run.completedAt }, "Sub-agent run auto-archived");
+                runs.delete(runId);
+            }
+        }
+        // Size cap: prune oldest completed runs if over limit
+        if (runs.size > MAX_RUNS) {
+            const completedRuns = [...runs.entries()]
+                .filter(([, r]) => r.status === "completed" || r.status === "failed")
+                .sort((a, b) => (a[1].completedAt ?? 0) - (b[1].completedAt ?? 0));
+            const toRemove = runs.size - MAX_RUNS;
+            for (let i = 0; i < toRemove && i < completedRuns.length; i++) {
+                runs.delete(completedRuns[i][0]);
+            }
+        }
+        // Queue timeout sweep -- fail queued spawns that exceeded queueTimeoutMs
+        const queueTimeoutMs = deps.config.subagentContext?.queueTimeoutMs ?? 120_000;
+        for (const [callerKey, queue] of spawnQueue) {
+            const timedOut = [];
+            for (let i = queue.length - 1; i >= 0; i--) {
+                const entry = queue[i];
+                if (now - entry.queuedAt > queueTimeoutMs) {
+                    queue.splice(i, 1);
+                    timedOut.push(entry.runId);
+                    const run = runs.get(entry.runId);
+                    if (run && run.status === "queued") {
+                        run.status = "failed";
+                        run.error = `Queue timeout: waited ${queueTimeoutMs}ms for an execution slot`;
+                        run.completedAt = now;
+                        deps.eventBus.emit("session:sub_agent_spawn_rejected", {
+                            parentSessionKey: callerKey,
+                            agentId: run.agentId,
+                            task: run.task,
+                            reason: "queue_timeout",
+                            currentDepth: run.depth,
+                            maxDepth: 0,
+                            currentChildren: 0,
+                            maxChildren: 0,
+                            timestamp: now,
+                        });
+                        deps.logger?.warn({
+                            runId: entry.runId,
+                            agentId: run.agentId,
+                            parentSessionKey: callerKey,
+                            queueTimeoutMs,
+                            hint: "Queued spawn timed out; increase queueTimeoutMs or reduce concurrent spawns",
+                            errorKind: "resource",
+                        }, "Queued spawn timed out");
+                    }
+                }
+            }
+            if (queue.length === 0) {
+                spawnQueue.delete(callerKey);
+            }
+        }
+        // Disk sweep for expired result files
+        if (deps.dataDir) {
+            const resultRetentionMs = deps.config.subagentContext?.resultRetentionMs ?? 86_400_000;
+            suppressError(sweepResultFiles(deps.dataDir, resultRetentionMs, deps.logger ?? undefined), "result-file-sweep");
+        }
+        // Ghost run sweep -- defense-in-depth for stuck runs
+        const ghostGraceMs = (deps.config.subagentContext?.maxRunTimeoutMs ?? 600_000) + 120_000;
+        for (const [runId, run] of runs) {
+            if (run.status !== "running")
+                continue;
+            const runningDurationMs = now - run.startedAt;
+            if (runningDurationMs <= ghostGraceMs)
+                continue;
+            deps.logger?.error({
+                runId, agentId: run.agentId,
+                runtimeMs: runningDurationMs,
+                graceMs: ghostGraceMs,
+                hint: "Run stuck in 'running' past grace period; force-failing as ghost run",
+                errorKind: "timeout",
+            }, "Ghost run detected and force-failed");
+            run.status = "failed";
+            run.completedAt = now;
+            run.error = `Ghost run: stuck in 'running' for ${(runningDurationMs / 1000).toFixed(0)}s (grace: ${(ghostGraceMs / 1000).toFixed(0)}s)`;
+            // Persist failure record
+            if (deps.dataDir) {
+                suppressError(persistFailureRecord({
+                    dataDir: deps.dataDir,
+                    sessionKey: run.sessionKey,
+                    runId,
+                    task: run.task,
+                    error: run.error,
+                    endReason: "ghost_sweep",
+                    runtimeMs: runningDurationMs,
+                }, deps.logger), "ghost-sweep-failure-record");
+            }
+            // Abort SDK session (best-effort)
+            if (deps.activeRunRegistry) {
+                const handle = deps.activeRunRegistry.get(run.sessionKey);
+                if (handle) {
+                    // eslint-disable-next-line no-restricted-syntax -- intentional fire-and-forget
+                    handle.abort().catch(() => { });
+                }
+            }
+            // Emit completion event
+            deps.eventBus.emit("session:sub_agent_completed", {
+                runId, agentId: run.agentId, success: false,
+                runtimeMs: runningDurationMs, tokensUsed: 0, cost: 0, timestamp: now,
+            });
+            // Stop proxy typing on ghost sweep
+            emitProxyStop(run, runId, "ghost_sweep");
+            // Deliver failure notification using stored announce channel
+            if (run.announceChannelType && run.announceChannelId) {
+                deliverFailureNotification({
+                    channelType: run.announceChannelType,
+                    channelId: run.announceChannelId,
+                    task: run.task,
+                    runtimeMs: runningDurationMs,
+                    runId,
+                    // eslint-disable-next-line no-restricted-syntax -- intentional fire-and-forget
+                }, deps).catch(() => { });
+            }
+            // Lifecycle hook (fire-and-forget)
+            if (deps.lifecycleHooks) {
+                deps.lifecycleHooks.onEnded({
+                    runId,
+                    agentId: run.agentId,
+                    parentSessionKey: run.callerSessionKey ?? "unknown",
+                    childSessionKey: run.sessionKey,
+                    endReason: "ghost_sweep",
+                    runtimeMs: runningDurationMs,
+                    tokensUsed: 0,
+                    cost: 0,
+                }).catch((hookErr) => {
+                    deps.logger?.warn({
+                        runId, err: hookErr,
+                        hint: "onSubagentEnded hook failed in ghost sweep path",
+                        errorKind: "internal",
+                    }, "Lifecycle hook onEnded failed");
+                });
+            }
+        }
+        // Dead-letter queue periodic drain
+        if (deps.deadLetterQueue) {
+            suppressError(deps.deadLetterQueue.drain(deps.sendToChannel), "dead-letter-sweep-drain");
+        }
+    }, SWEEP_INTERVAL_MS);
+    sweepInterval.unref();
+    // Event-driven DLQ drain on provider recovery
+    if (deps.deadLetterQueue) {
+        deps.eventBus.on("provider:recovered", () => {
+            suppressError(deps.deadLetterQueue.drain(deps.sendToChannel), "dead-letter-recovery-drain");
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    function spawn(params) {
+        // 0. Resolve depth and config values for limit enforcement
+        const currentDepth = params.depth ?? 0;
+        const maxDepth = params.maxDepth ?? deps.config.subagentContext?.maxSpawnDepth ?? 3;
+        const isGraphSpawn = params.callerType === "graph";
+        // Depth check (applies to ALL spawns including graph)
+        if (currentDepth >= maxDepth) {
+            deps.eventBus.emit("session:sub_agent_spawn_rejected", {
+                parentSessionKey: params.callerSessionKey ?? "unknown",
+                agentId: params.agentId,
+                task: params.task,
+                reason: "depth_exceeded",
+                currentDepth,
+                maxDepth,
+                currentChildren: 0,
+                maxChildren: 0,
+                timestamp: Date.now(),
+            });
+            deps.logger?.warn({
+                agentId: params.agentId,
+                parentSessionKey: params.callerSessionKey ?? "unknown",
+                reason: "depth_exceeded",
+                currentDepth,
+                maxDepth,
+                hint: "Spawn rejected: depth limit exceeded; reduce spawn nesting or increase maxSpawnDepth config",
+                errorKind: "resource",
+            }, "Subagent spawn rejected");
+            throw new Error(`Spawn rejected: depth limit exceeded (current: ${currentDepth}, max: ${maxDepth}). This sub-agent cannot spawn further children at this nesting level.`);
+        }
+        // Children check (bypassed for graph spawns)
+        if (!isGraphSpawn && params.callerSessionKey) {
+            const maxChildren = deps.config.subagentContext?.maxChildrenPerAgent ?? 5;
+            const activeChildren = countActiveChildren(params.callerSessionKey);
+            if (activeChildren >= maxChildren) {
+                const maxQueuedPerAgent = deps.config.subagentContext?.maxQueuedPerAgent ?? 10;
+                // maxQueuedPerAgent === 0 means queuing is disabled -- preserve old throw behavior
+                if (maxQueuedPerAgent === 0) {
+                    deps.eventBus.emit("session:sub_agent_spawn_rejected", {
+                        parentSessionKey: params.callerSessionKey,
+                        agentId: params.agentId,
+                        task: params.task,
+                        reason: "children_exceeded",
+                        currentDepth,
+                        maxDepth,
+                        currentChildren: activeChildren,
+                        maxChildren,
+                        timestamp: Date.now(),
+                    });
+                    deps.logger?.warn({
+                        agentId: params.agentId,
+                        parentSessionKey: params.callerSessionKey,
+                        reason: "children_exceeded",
+                        activeChildren,
+                        maxChildren,
+                        hint: "Spawn rejected: active children limit exceeded; wait for existing sub-agents to complete",
+                        errorKind: "resource",
+                    }, "Subagent spawn rejected");
+                    throw new Error(`Spawn rejected: active children limit exceeded (current: ${activeChildren}, max: ${maxChildren}). Wait for existing sub-agents to complete before spawning more.`);
+                }
+                // Check queue capacity
+                const queueSize = spawnQueue.get(params.callerSessionKey)?.length ?? 0;
+                if (queueSize >= maxQueuedPerAgent) {
+                    deps.eventBus.emit("session:sub_agent_spawn_rejected", {
+                        parentSessionKey: params.callerSessionKey,
+                        agentId: params.agentId,
+                        task: params.task,
+                        reason: "queue_full",
+                        currentDepth,
+                        maxDepth,
+                        currentChildren: activeChildren,
+                        maxChildren,
+                        timestamp: Date.now(),
+                    });
+                    deps.logger?.warn({
+                        agentId: params.agentId,
+                        parentSessionKey: params.callerSessionKey,
+                        reason: "queue_full",
+                        activeChildren,
+                        maxChildren,
+                        queueSize,
+                        maxQueuedPerAgent,
+                        hint: "Spawn rejected: queue full; wait for queued or active sub-agents to complete",
+                        errorKind: "resource",
+                    }, "Subagent spawn rejected");
+                    throw new Error(`Spawn rejected: queue full (queued: ${queueSize}, max: ${maxQueuedPerAgent}). Wait for existing sub-agents to complete before spawning more.`);
+                }
+                // Queue the spawn
+                const queuedRunId = randomUUID();
+                const now = Date.now();
+                const queuedRun = {
+                    runId: queuedRunId,
+                    status: "queued",
+                    agentId: params.agentId,
+                    task: params.task,
+                    sessionKey: "",
+                    startedAt: 0,
+                    queuedAt: now,
+                    requesterOrigin: params.requesterOrigin,
+                    depth: currentDepth,
+                    callerSessionKey: params.callerSessionKey,
+                    announceChannelType: params.announceChannelType,
+                    announceChannelId: params.announceChannelId,
+                    graphId: params.graphId,
+                    nodeId: params.nodeId,
+                    abortGroup: params.callerType === "graph" && params.graphId
+                        ? `graph:${params.graphId}`
+                        : params.callerSessionKey,
+                };
+                runs.set(queuedRunId, queuedRun);
+                const callerQueue = spawnQueue.get(params.callerSessionKey) ?? [];
+                callerQueue.push({ runId: queuedRunId, params, queuedAt: now });
+                spawnQueue.set(params.callerSessionKey, callerQueue);
+                deps.eventBus.emit("session:sub_agent_spawn_queued", {
+                    runId: queuedRunId,
+                    parentSessionKey: params.callerSessionKey,
+                    agentId: params.agentId,
+                    task: params.task,
+                    queuePosition: callerQueue.length,
+                    activeChildren,
+                    maxChildren,
+                    timestamp: now,
+                });
+                deps.logger?.debug({
+                    runId: queuedRunId,
+                    agentId: params.agentId,
+                    parentSessionKey: params.callerSessionKey,
+                    queuePosition: callerQueue.length,
+                    activeChildren,
+                    maxChildren,
+                }, "Sub-agent spawn queued");
+                return queuedRunId;
+            }
+        }
+        // 1. Allowlist check
+        if (deps.config.allowAgents.length > 0 &&
+            !deps.config.allowAgents.includes(params.agentId)) {
+            throw new Error(`Agent "${params.callerAgentId}" is not allowed to spawn "${params.agentId}". Allowed: ${deps.config.allowAgents.join(", ")}`);
+        }
+        // Normal (non-queued) path: create run and start execution
+        const runId = randomUUID();
+        const run = {
+            runId, status: "running", agentId: params.agentId,
+            task: params.task, sessionKey: "", startedAt: Date.now(),
+            requesterOrigin: params.requesterOrigin,
+            depth: currentDepth,
+            callerSessionKey: params.callerSessionKey,
+            announceChannelType: params.announceChannelType,
+            announceChannelId: params.announceChannelId,
+            graphId: params.graphId,
+            nodeId: params.nodeId,
+            abortGroup: params.callerType === "graph" && params.graphId
+                ? `graph:${params.graphId}`
+                : params.callerSessionKey,
+        };
+        runs.set(runId, run);
+        startExecution(runId, run, params, currentDepth, maxDepth);
+        // 6. Return runId immediately (non-blocking)
+        return runId;
+    }
+    /**
+     * Start execution for a run: create session, emit events, launch async execution.
+     * Called for both normal spawns and promoted queued spawns.
+     */
+    function startExecution(runId, run, params, currentDepth, maxDepth) {
+        // Create sub-agent session
+        let subSessionKey;
+        let formattedKey;
+        if (params.reuseSessionKey) {
+            // Reuse existing persistent session -- skip session creation.
+            // The session already has prior round conversation history on disk.
+            const parsed = parseFormattedSessionKey(params.reuseSessionKey);
+            if (!parsed) {
+                deps.logger?.error({ runId, reuseSessionKey: params.reuseSessionKey, hint: "Invalid reuseSessionKey format, falling back to new session", errorKind: "validation" }, "Failed to parse reuseSessionKey");
+                // Fall through to normal session creation
+                subSessionKey = { tenantId: deps.tenantId, userId: `sub-agent-${runId}`, channelId: `sub-agent:${runId}` };
+                formattedKey = formatSessionKey(subSessionKey);
+                deps.sessionStore.save(subSessionKey, [], {
+                    parentSessionKey: params.callerSessionKey,
+                    spawnedByAgent: params.callerAgentId,
+                    spawnedAt: Date.now(),
+                    taskDescription: params.task,
+                    runId,
+                    modelOverride: params.model,
+                    spawnDepth: currentDepth + 1,
+                    maxSpawnDepth: maxDepth,
+                    artifactRefs: params.artifactRefs ?? [],
+                    objective: params.objective ?? "",
+                    domainKnowledge: params.domainKnowledge ?? [],
+                    toolGroups: params.toolGroups ?? [],
+                    includeParentHistory: params.includeParentHistory ?? "none",
+                    graphSharedDir: params.graphSharedDir ?? "",
+                    discoveredDeferredTools: params.discoveredDeferredTools ?? [],
+                    graphToolNames: params.graphToolNames ?? [],
+                    graphNodeDepth: params.graphNodeDepth,
+                    isLeafNode: params.isLeafNode ?? false,
+                });
+            }
+            else {
+                formattedKey = params.reuseSessionKey;
+                subSessionKey = { tenantId: parsed.tenantId, userId: parsed.userId, channelId: parsed.channelId };
+                deps.logger?.info({ runId, reuseSessionKey: params.reuseSessionKey, agentId: params.agentId }, "Reusing persistent session for multi-round driver");
+                // Do NOT call sessionStore.save -- session already exists with prior messages
+            }
+        }
+        else {
+            // Normal path: create new session
+            subSessionKey = { tenantId: deps.tenantId, userId: `sub-agent-${runId}`, channelId: `sub-agent:${runId}` };
+            formattedKey = formatSessionKey(subSessionKey);
+            deps.sessionStore.save(subSessionKey, [], {
+                parentSessionKey: params.callerSessionKey,
+                spawnedByAgent: params.callerAgentId,
+                spawnedAt: Date.now(),
+                taskDescription: params.task,
+                runId,
+                modelOverride: params.model,
+                spawnDepth: currentDepth + 1,
+                maxSpawnDepth: maxDepth,
+                artifactRefs: params.artifactRefs ?? [],
+                objective: params.objective ?? "",
+                domainKnowledge: params.domainKnowledge ?? [],
+                toolGroups: params.toolGroups ?? [],
+                includeParentHistory: params.includeParentHistory ?? "none",
+                graphSharedDir: params.graphSharedDir ?? "",
+                discoveredDeferredTools: params.discoveredDeferredTools ?? [],
+                graphToolNames: params.graphToolNames ?? [],
+                graphNodeDepth: params.graphNodeDepth,
+                isLeafNode: params.isLeafNode ?? false,
+            });
+        }
+        // Update run with session info and running status
+        run.sessionKey = formattedKey;
+        run.status = "running";
+        run.startedAt = Date.now();
+        deps.logger?.info({
+            runId, agentId: params.agentId,
+            callerAgentId: params.callerAgentId ?? "unknown",
+            parentSessionKey: params.callerSessionKey ?? "unknown",
+            task: params.task.slice(0, 200),
+            maxSteps: params.max_steps ?? deps.config.subAgentMaxSteps,
+            toolProfile: deps.config.subAgentToolGroups,
+        }, "Sub-agent spawn initiated");
+        // Emit spawn event
+        deps.eventBus.emit("session:sub_agent_spawned", {
+            runId, parentSessionKey: params.callerSessionKey ?? "unknown",
+            agentId: params.agentId, task: params.task, timestamp: Date.now(),
+        });
+        // Async execution
+        const execPromise = (async () => {
+            // Lifecycle hook - prepareSpawn
+            let rollbackHandle;
+            if (deps.lifecycleHooks) {
+                try {
+                    rollbackHandle = await deps.lifecycleHooks.prepareSpawn({
+                        runId,
+                        parentSessionKey: params.callerSessionKey ?? "unknown",
+                        childSessionKey: formattedKey,
+                        agentId: params.agentId,
+                        task: params.task,
+                        depth: currentDepth,
+                        maxDepth,
+                    });
+                }
+                catch (hookErr) {
+                    deps.logger?.warn({
+                        runId, err: hookErr,
+                        hint: "prepareSubagentSpawn hook failed; proceeding with legacy spawn",
+                        errorKind: "internal",
+                    }, "Lifecycle hook prepareSpawn failed");
+                }
+            }
+            // Hoist traceId for availability in catch block (failure record correlation)
+            const traceId = params.graphTraceId ?? randomUUID();
+            try {
+                deps.logger?.info({
+                    runId, agentId: params.agentId,
+                    ...(params.graphId ? { graphId: params.graphId } : {}),
+                    ...(params.nodeId ? { nodeId: params.nodeId } : {}),
+                }, "Sub-agent execution started");
+                const parsed = parseFormattedSessionKey(formattedKey);
+                // Propagate delivery origin into ALS so sub-agent tool calls
+                // (e.g. pipeline execute -> graph.execute RPC) include announce channel fields.
+                // Without this, setup-tools.ts cannot inject _callerChannelType/_callerChannelId.
+                const subDeliveryOrigin = run.announceChannelType && run.announceChannelId
+                    ? {
+                        channelType: run.announceChannelType,
+                        channelId: run.announceChannelId,
+                        userId: parsed?.userId ?? "sub-agent",
+                        tenantId: parsed?.tenantId ?? deps.tenantId,
+                    }
+                    : undefined;
+                const result = await runWithContext({
+                    traceId,
+                    tenantId: parsed?.tenantId ?? deps.tenantId,
+                    userId: parsed?.userId ?? "sub-agent",
+                    sessionKey: formattedKey,
+                    startedAt: Date.now(),
+                    trustLevel: "admin",
+                    // Propagate channel context for downstream tool RPC injection
+                    ...(run.announceChannelType && { channelType: run.announceChannelType }),
+                    ...(subDeliveryOrigin && { deliveryOrigin: subDeliveryOrigin }),
+                }, () => deps.executeAgent(params.agentId, subSessionKey, params.task, params.max_steps, params.callerAgentId, params.graphId && params.nodeId
+                    ? { graphId: params.graphId, nodeId: params.nodeId, reuseSessionKey: params.reuseSessionKey, graphNodeDepth: params.graphNodeDepth }
+                    : params.reuseSessionKey
+                        ? { reuseSessionKey: params.reuseSessionKey }
+                        : undefined));
+                // Guard: if already killed, skip completion logic
+                if (run.status === "failed")
+                    return;
+                const completedAt = Date.now();
+                run.status = "completed";
+                run.completedAt = completedAt;
+                run.result = result;
+                // Populate run.error for non-successful completions so graph coordinator
+                // and downstream consumers see a meaningful error instead of "Unknown error".
+                if (result.finishReason !== "stop" && result.finishReason !== "end_turn") {
+                    run.error = result.errorContext?.originalError
+                        ?? `Execution completed with finishReason: ${result.finishReason}`;
+                }
+                // Warn on empty response — may indicate prompt or context issues
+                if (!result.response || result.response.trim().length === 0) {
+                    deps.logger?.warn({
+                        runId, agentId: params.agentId, finishReason: result.finishReason,
+                        hint: "Sub-agent returned empty response; check task prompt clarity and model context limits",
+                        errorKind: "internal",
+                    }, "Sub-agent produced empty output");
+                }
+                const runtimeMs = completedAt - run.startedAt;
+                // Compute cache effectiveness before condense() for disk persistence.
+                // Formula: cacheRead/(cacheRead+cacheWrite), 0 when no cache activity.
+                const cacheRead = result.tokensUsed.cacheRead ?? 0;
+                const cacheWrite = result.tokensUsed.cacheWrite ?? 0;
+                const cacheable = cacheRead + cacheWrite;
+                const cacheEffectiveness = cacheable > 0 ? cacheRead / cacheable : 0;
+                // Result condensation pipeline
+                let condensedResult;
+                if (deps.resultCondenser) {
+                    try {
+                        condensedResult = await deps.resultCondenser.condense({
+                            fullResult: result.response,
+                            task: params.task,
+                            runId,
+                            sessionKey: formattedKey,
+                            agentId: params.agentId,
+                            model: deps.condenserModel,
+                            apiKey: deps.condenserApiKey,
+                            // Parent trace correlation for cross-session diagnostics
+                            parentTraceId: traceId,
+                            // Graph context propagation (graphId/nodeId now available via SpawnParams)
+                            graphId: params.graphId,
+                            nodeId: params.nodeId,
+                            // Token/cost usage breakdown; cache fields for post-mortem analysis
+                            usage: {
+                                totalTokens: result.tokensUsed.total,
+                                costUsd: result.cost.total,
+                                cacheReadTokens: cacheRead,
+                                cacheWriteTokens: cacheWrite,
+                                cacheSavedUsd: result.cost.cacheSaved ?? 0,
+                                cacheEffectiveness: Number(cacheEffectiveness.toFixed(3)),
+                            },
+                            // Error context for non-successful executions
+                            errorContext: result.errorContext,
+                            // Tool metadata plumbed from executor via bridge
+                            toolCallHistory: result.toolCallHistory,
+                        });
+                        deps.eventBus.emit("session:sub_agent_result_condensed", {
+                            runId,
+                            agentId: params.agentId,
+                            level: condensedResult.level,
+                            originalTokens: condensedResult.originalTokens,
+                            condensedTokens: condensedResult.condensedTokens,
+                            compressionRatio: condensedResult.compressionRatio,
+                            taskComplete: condensedResult.result.taskComplete,
+                            diskPath: condensedResult.diskPath,
+                            timestamp: Date.now(),
+                        });
+                        deps.logger?.debug({
+                            runId, agentId: params.agentId,
+                            level: condensedResult.level,
+                            originalTokens: condensedResult.originalTokens,
+                            condensedTokens: condensedResult.condensedTokens,
+                            compressionRatio: condensedResult.compressionRatio,
+                        }, "Result condensation completed");
+                    }
+                    catch (condensErr) {
+                        deps.logger?.warn({
+                            runId, err: condensErr,
+                            hint: "Result condensation failed; using raw response for announcement",
+                            errorKind: "internal",
+                        }, "ResultCondenser failed");
+                    }
+                }
+                // Emit completion event
+                const isSuccess = result.finishReason === "stop" || result.finishReason === "end_turn";
+                deps.eventBus.emit("session:sub_agent_completed", {
+                    runId, agentId: params.agentId, success: isSuccess,
+                    runtimeMs, tokensUsed: result.tokensUsed.total,
+                    cost: result.cost.total, timestamp: completedAt,
+                    cacheReadTokens: cacheRead,
+                    cacheWriteTokens: cacheWrite,
+                });
+                // Post-execution output validation (best-effort, never blocks)
+                let validationResults;
+                if (params.expected_outputs && params.expected_outputs.length > 0) {
+                    try {
+                        validationResults = await validateOutputs(params.expected_outputs);
+                        const missing = validationResults.filter((v) => !v.exists);
+                        if (missing.length > 0) {
+                            deps.logger?.warn({
+                                runId,
+                                missingFiles: missing.map((v) => v.path),
+                                hint: "Sub-agent did not produce all expected output files; check task description clarity",
+                                errorKind: "validation",
+                            }, "Sub-agent output validation: missing files");
+                        }
+                    }
+                    catch (validationErr) {
+                        deps.logger?.warn({
+                            runId,
+                            err: validationErr,
+                            hint: "Output validation failed unexpectedly; announcement will proceed without validation data",
+                            errorKind: "internal",
+                        }, "Sub-agent output validation error");
+                    }
+                }
+                // Classify abort if finishReason is abnormal (not stop/end_turn)
+                let abortClassification;
+                if (result.finishReason !== "stop" && result.finishReason !== "end_turn") {
+                    try {
+                        abortClassification = classifyAbortReason(result.finishReason);
+                    }
+                    catch { /* classification must never block */ }
+                }
+                // WARN log for abort events
+                if (abortClassification) {
+                    deps.logger?.warn({
+                        runId, agentId: params.agentId,
+                        abortReason: abortClassification.category,
+                        abortSeverity: abortClassification.severity,
+                        hint: abortClassification.hint,
+                        errorKind: "resource",
+                        finishReason: result.finishReason,
+                        // Include error context when available for root-cause investigation
+                        ...(result.errorContext?.errorType && { errorType: result.errorContext.errorType }),
+                        ...(result.errorContext?.originalError && { errorDetail: result.errorContext.originalError }),
+                    }, "Sub-agent aborted");
+                }
+                // Enriched INFO log (after validation so filesCreated is available)
+                deps.logger?.info({
+                    runId, agentId: params.agentId, success: isSuccess, durationMs: runtimeMs,
+                    finishReason: result.finishReason,
+                    stepsExecuted: result.stepsExecuted,
+                    stepCount: result.stepsExecuted,
+                    tokensUsed: result.tokensUsed.total, cost: result.cost.total,
+                    responseLength: result.response.length,
+                    filesCreated: validationResults?.filter((v) => v.exists).length ?? 0,
+                    cacheReadTokens: cacheRead,
+                    cacheWriteTokens: cacheWrite,
+                    cacheEffectiveness: Number(cacheEffectiveness.toFixed(3)),
+                    ...(params.graphId ? { graphId: params.graphId } : {}),
+                    ...(params.nodeId ? { nodeId: params.nodeId } : {}),
+                }, "Sub-agent execution completed");
+                // Persist completion summary to memory for cross-session recall
+                if (deps.memoryAdapter) {
+                    try {
+                        let status;
+                        if (abortClassification) {
+                            status = `Halted (${abortClassification.category})`;
+                        }
+                        else if (result.finishReason === "error" && result.errorContext) {
+                            const retryHint = result.errorContext.retryable ? ", retryable" : "";
+                            const toolHint = result.errorContext.failingTool ? ` on ${result.errorContext.failingTool}` : "";
+                            status = `Halted (${result.errorContext.errorType}${toolHint}${retryHint})`;
+                        }
+                        else if (result.finishReason === "error") {
+                            status = "Halted (error)";
+                        }
+                        else {
+                            status = "Success";
+                        }
+                        const taskSnippet = params.task.length > 500
+                            ? params.task.slice(0, 497) + "..."
+                            : params.task;
+                        const sanitizedResponse = sanitizeAssistantResponse(result.response);
+                        const resultSnippet = sanitizedResponse.length > 500
+                            ? sanitizedResponse.slice(0, 497) + "..."
+                            : sanitizedResponse;
+                        const content = [
+                            `Sub-agent task ${status === "Success" ? "completed" : "halted"}.`,
+                            `Task: ${taskSnippet}`,
+                            `Status: ${status}`,
+                            resultSnippet ? `Result: ${resultSnippet}` : null,
+                            `Runtime: ${(runtimeMs / 1000).toFixed(1)}s | Steps: ${result.stepsExecuted} | Cost: $${result.cost.total.toFixed(4)}`,
+                            `Session: ${formattedKey}`,
+                        ].filter(Boolean).join("\n");
+                        await deps.memoryAdapter.store({
+                            id: randomUUID(),
+                            tenantId: deps.tenantId,
+                            agentId: params.agentId,
+                            userId: "system",
+                            content,
+                            trustLevel: "system",
+                            source: { who: "sub-agent-runner", sessionKey: formattedKey },
+                            tags: ["sub-agent-result", "task-completion", ...(abortClassification ? ["aborted"] : [])],
+                            createdAt: Date.now(),
+                            sourceType: "tool",
+                        });
+                        deps.logger?.debug({ runId, agentId: params.agentId }, "Sub-agent completion persisted to memory");
+                    }
+                    catch (memErr) {
+                        deps.logger?.warn({
+                            runId, err: memErr,
+                            hint: "Failed to persist sub-agent completion to memory; cross-session recall may be incomplete",
+                            errorKind: "internal",
+                        }, "Sub-agent memory persistence failed");
+                    }
+                }
+                // Route provider_degraded to failure notification path
+                // When isDegraded() skips the LLM call, executor returns empty response with
+                // finishReason "provider_degraded". Route to deliverFailureNotification instead
+                // of deliverAnnouncement to avoid sending an empty/malformed success message.
+                if (result.finishReason === "provider_degraded") {
+                    if (params.announceChannelType && params.announceChannelId) {
+                        await deliverFailureNotification({
+                            channelType: params.announceChannelType,
+                            channelId: params.announceChannelId,
+                            task: params.task,
+                            runtimeMs,
+                            runId,
+                        }, deps);
+                    }
+                }
+                else if (params.announceChannelType && params.announceChannelId) {
+                    // Announce with stats
+                    if (!result.response.includes("ANNOUNCE_SKIP")) {
+                        // Use NarrativeCaster for tagged result announcement.
+                        // Skip NarrativeCaster for error results — buildAnnouncementMessage
+                        // enriches the status label with errorContext (e.g., "Halted (PromptTimeout, retryable)")
+                        // which the NarrativeCaster would lose.
+                        let announcementText;
+                        if (condensedResult && deps.narrativeCaster && result.finishReason !== "error") {
+                            announcementText = deps.narrativeCaster.cast({
+                                condensedResult,
+                                task: params.task,
+                                runtimeMs,
+                                stepsExecuted: result.stepsExecuted,
+                                tokensUsed: result.tokensUsed.total,
+                                cost: result.cost.total,
+                                sessionKey: formattedKey,
+                            });
+                        }
+                        else {
+                            // Legacy fallback: no condenser or no caster
+                            announcementText = buildAnnouncementMessage({
+                                task: params.task,
+                                status: "completed",
+                                response: condensedResult
+                                    ? `${condensedResult.result.summary}\n\nFull result: ${condensedResult.diskPath}`
+                                    : sanitizeAssistantResponse(result.response),
+                                runtimeMs,
+                                stepsExecuted: result.stepsExecuted,
+                                tokensUsed: result.tokensUsed.total,
+                                cost: result.cost.total,
+                                finishReason: result.finishReason,
+                                sessionKey: formattedKey,
+                                validation: validationResults,
+                                abort: abortClassification,
+                                errorContext: result.errorContext,
+                            });
+                        }
+                        await deliverAnnouncement({
+                            announcementText,
+                            announceChannelType: params.announceChannelType,
+                            announceChannelId: params.announceChannelId,
+                            callerAgentId: params.callerAgentId,
+                            callerSessionKey: params.callerSessionKey,
+                            runId,
+                        }, deps);
+                    }
+                }
+                else {
+                    // Log explicit reason when announcement cannot be routed
+                    deps.logger?.debug({
+                        runId,
+                        suppressAnnounceReason: params.requesterOrigin ? "no_channel_params" : "no_origin",
+                        hasOrigin: !!params.requesterOrigin,
+                    }, "Sub-agent announcement skipped: no announce channel");
+                }
+                // Safety-net proxy stop — announceToParent's own finally block handles
+                // the announcement-scoped typing. This catches edge cases where announcement was skipped.
+                emitProxyStop(run, runId, "completed");
+                // Lifecycle hook - onEnded (success path, after condensation/casting/announcement)
+                if (deps.lifecycleHooks) {
+                    try {
+                        await deps.lifecycleHooks.onEnded({
+                            runId,
+                            agentId: params.agentId,
+                            parentSessionKey: params.callerSessionKey ?? "unknown",
+                            childSessionKey: formattedKey,
+                            endReason: "completed",
+                            condensedResult: condensedResult ? { level: condensedResult.level, condensedTokens: condensedResult.condensedTokens } : undefined,
+                            runtimeMs,
+                            tokensUsed: result.tokensUsed.total,
+                            cost: result.cost.total,
+                        });
+                    }
+                    catch (hookErr) {
+                        deps.logger?.warn({
+                            runId, err: hookErr,
+                            hint: "onSubagentEnded hook failed; result already delivered",
+                            errorKind: "internal",
+                        }, "Lifecycle hook onEnded failed");
+                    }
+                }
+            }
+            catch (error) {
+                // Guard: if already killed, skip error handling logic
+                if (run.status === "failed")
+                    return;
+                const completedAt = Date.now();
+                run.status = "failed";
+                run.completedAt = completedAt;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                run.error = errorMessage;
+                const runtimeMs = completedAt - run.startedAt;
+                deps.logger?.error({
+                    runId,
+                    durationMs: runtimeMs,
+                    err: error,
+                    hint: "Sub-agent execution failed; check agent config, model availability, and API key",
+                    errorKind: "internal",
+                }, "Sub-agent execution failed");
+                // Persist failure record BEFORE rollback deletes the directory
+                if (deps.dataDir) {
+                    await persistFailureRecord({
+                        dataDir: deps.dataDir,
+                        sessionKey: formattedKey,
+                        runId,
+                        task: params.task,
+                        error: errorMessage,
+                        endReason: "failed",
+                        runtimeMs,
+                        // Parent trace correlation for failure records
+                        parentTraceId: traceId,
+                    }, deps.logger);
+                }
+                // Rollback disk directory on spawn failure
+                if (rollbackHandle) {
+                    try {
+                        await rollbackHandle.rollback();
+                    }
+                    catch { /* swallow -- rollback has its own WARN logging */ }
+                }
+                // Classify abort from error context
+                let abortClassification;
+                try {
+                    const errorCause = error instanceof Error && error.cause
+                        ? (error.cause instanceof Error ? error.cause.message : String(error.cause))
+                        : undefined;
+                    abortClassification = classifyAbortReason("error", errorMessage, errorCause);
+                }
+                catch { /* classification must never block */ }
+                // WARN log for abort classification in error path
+                if (abortClassification) {
+                    deps.logger?.warn({
+                        runId, agentId: params.agentId,
+                        abortReason: abortClassification.category,
+                        abortSeverity: abortClassification.severity,
+                        hint: abortClassification.hint,
+                        errorKind: "resource",
+                        // Include actual error type for root-cause investigation (not just "unknown")
+                        ...(error instanceof Error && { errorType: error.constructor.name }),
+                        ...(error instanceof Error && error.message && { errorDetail: error.message }),
+                        ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
+                    }, "Sub-agent aborted");
+                }
+                // Emit failure event
+                deps.eventBus.emit("session:sub_agent_completed", {
+                    runId, agentId: params.agentId, success: false,
+                    runtimeMs, tokensUsed: 0, cost: 0, timestamp: completedAt,
+                });
+                // Stop proxy typing before failure notification
+                emitProxyStop(run, runId, "failed");
+                // Announce failure to channel -- LLM-free direct send
+                if (params.announceChannelType && params.announceChannelId) {
+                    await deliverFailureNotification({
+                        channelType: params.announceChannelType,
+                        channelId: params.announceChannelId,
+                        task: params.task,
+                        runtimeMs,
+                        runId,
+                    }, deps);
+                }
+                else {
+                    // Log explicit reason when failure announcement cannot be routed
+                    deps.logger?.debug({
+                        runId,
+                        suppressAnnounceReason: params.requesterOrigin ? "no_channel_params" : "no_origin",
+                        hasOrigin: !!params.requesterOrigin,
+                    }, "Sub-agent failure announcement skipped: no announce channel");
+                }
+                // Lifecycle hook - onEnded (failure path)
+                if (deps.lifecycleHooks) {
+                    try {
+                        await deps.lifecycleHooks.onEnded({
+                            runId,
+                            agentId: params.agentId,
+                            parentSessionKey: params.callerSessionKey ?? "unknown",
+                            childSessionKey: formattedKey,
+                            endReason: "failed",
+                            runtimeMs,
+                            tokensUsed: 0,
+                            cost: 0,
+                        });
+                    }
+                    catch (hookErr) {
+                        deps.logger?.warn({
+                            runId, err: hookErr,
+                            hint: "onSubagentEnded hook failed in error path",
+                            errorKind: "internal",
+                        }, "Lifecycle hook onEnded failed");
+                    }
+                }
+            }
+        })();
+        // Per-run watchdog timer
+        const subagentCtx = deps.config.subagentContext;
+        const perStepMs = subagentCtx?.perStepTimeoutMs ?? 60_000;
+        const maxRunMs = subagentCtx?.maxRunTimeoutMs ?? 600_000;
+        const runTimeoutMs = params.max_steps
+            ? Math.min(params.max_steps * perStepMs, maxRunMs)
+            : maxRunMs;
+        const watchdogTimer = setTimeout(() => {
+            // Guard: if already completed/failed/killed, skip
+            if (run.status !== "running")
+                return;
+            const completedAt = Date.now();
+            const runtimeMs = completedAt - run.startedAt;
+            run.status = "failed";
+            run.completedAt = completedAt;
+            run.error = `Execution timeout: exceeded ${runTimeoutMs}ms wall-clock limit`;
+            deps.logger?.error({
+                runId, agentId: run.agentId,
+                runtimeMs, timeoutMs: runTimeoutMs,
+                hint: "Sub-agent watchdog timeout; increase maxRunTimeoutMs or perStepTimeoutMs if tasks legitimately need more time",
+                errorKind: "timeout",
+            }, "Sub-agent watchdog timeout");
+            // Persist failure record (fire-and-forget)
+            if (deps.dataDir) {
+                suppressError(persistFailureRecord({
+                    dataDir: deps.dataDir,
+                    sessionKey: run.sessionKey,
+                    runId,
+                    task: run.task,
+                    error: run.error,
+                    endReason: "watchdog_timeout",
+                    runtimeMs,
+                }, deps.logger), "watchdog-failure-record");
+            }
+            // Abort SDK session (keyed by sessionKey, NOT runId)
+            if (deps.activeRunRegistry) {
+                const handle = deps.activeRunRegistry.get(run.sessionKey);
+                if (handle) {
+                    handle.abort().catch((abortErr) => {
+                        deps.logger?.debug({ runId, err: abortErr }, "Watchdog SDK abort best-effort failed");
+                    });
+                }
+            }
+            // Emit completion event
+            deps.eventBus.emit("session:sub_agent_completed", {
+                runId, agentId: run.agentId, success: false,
+                runtimeMs, tokensUsed: 0, cost: 0, timestamp: completedAt,
+            });
+            // Stop proxy typing on watchdog timeout
+            emitProxyStop(run, runId, "watchdog_timeout");
+            // Deliver failure notification (LLM-free)
+            if (params.announceChannelType && params.announceChannelId) {
+                deliverFailureNotification({
+                    channelType: params.announceChannelType,
+                    channelId: params.announceChannelId,
+                    task: params.task,
+                    runtimeMs,
+                    runId,
+                    // eslint-disable-next-line no-restricted-syntax -- intentional fire-and-forget
+                }, deps).catch(() => { });
+            }
+            // Lifecycle hook (fire-and-forget)
+            if (deps.lifecycleHooks) {
+                deps.lifecycleHooks.onEnded({
+                    runId,
+                    agentId: run.agentId,
+                    parentSessionKey: run.callerSessionKey ?? "unknown",
+                    childSessionKey: run.sessionKey,
+                    endReason: "watchdog_timeout",
+                    runtimeMs,
+                    tokensUsed: 0,
+                    cost: 0,
+                }).catch((hookErr) => {
+                    deps.logger?.warn({
+                        runId, err: hookErr,
+                        hint: "onSubagentEnded hook failed in watchdog path",
+                        errorKind: "internal",
+                    }, "Lifecycle hook onEnded failed");
+                });
+            }
+        }, runTimeoutMs);
+        // Clear watchdog on normal completion/failure
+        execPromise.finally(() => clearTimeout(watchdogTimer));
+        activePromises.add(execPromise);
+        execPromise.finally(() => {
+            activePromises.delete(execPromise);
+            // Drain queue when a slot opens (use abortGroup for graph-scoped draining)
+            const drainKey = run.abortGroup ?? run.callerSessionKey;
+            if (drainKey) {
+                drainQueue(drainKey);
+            }
+        });
+    }
+    /**
+     * Promote queued spawns to running when active children count drops below limit.
+     * Called from the .finally() of each execution promise.
+     */
+    function drainQueue(callerSessionKey) {
+        const queue = spawnQueue.get(callerSessionKey);
+        if (!queue || queue.length === 0) {
+            spawnQueue.delete(callerSessionKey);
+            return;
+        }
+        const maxChildren = deps.config.subagentContext?.maxChildrenPerAgent ?? 5;
+        let activeChildren = countActiveChildren(callerSessionKey);
+        while (activeChildren < maxChildren && queue.length > 0) {
+            const next = queue.shift();
+            const run = runs.get(next.runId);
+            if (!run || run.status !== "queued")
+                continue;
+            const currentDepth = next.params.depth ?? 0;
+            const maxDepth = next.params.maxDepth ?? deps.config.subagentContext?.maxSpawnDepth ?? 3;
+            startExecution(next.runId, run, next.params, currentDepth, maxDepth);
+            activeChildren++;
+        }
+        if (queue.length === 0) {
+            spawnQueue.delete(callerSessionKey);
+        }
+    }
+    function getRunStatus(runId) {
+        return runs.get(runId);
+    }
+    /**
+     * List tracked sub-agent runs, optionally filtered by recency.
+     * @param recentMinutes - Only include runs started within the last N minutes.
+     *   If undefined or 0, all runs are returned.
+     * @returns Shallow copies of matching runs sorted by startedAt descending.
+     */
+    function listRuns(recentMinutes) {
+        const cutoff = recentMinutes && recentMinutes > 0
+            ? Date.now() - recentMinutes * 60_000
+            : 0;
+        return [...runs.values()]
+            .filter((r) => (r.startedAt || r.queuedAt || 0) >= cutoff)
+            .sort((a, b) => (b.startedAt || b.queuedAt || 0) - (a.startedAt || a.queuedAt || 0))
+            .map((r) => ({ ...r }));
+    }
+    /**
+     * Kill a running sub-agent by marking it as failed.
+     * The in-flight executeAgent promise will eventually complete (or error)
+     * and find the run already marked -- it skips its completion logic.
+     * @param runId - The run ID to kill
+     * @returns Result indicating success or failure with error message
+     */
+    function killRun(runId) {
+        const run = runs.get(runId);
+        if (!run) {
+            return { killed: false, error: `Unknown run ID: ${runId}` };
+        }
+        if (run.status !== "running" && run.status !== "queued") {
+            return { killed: false, error: `Run ${runId} is not running (status: ${run.status})` };
+        }
+        run.status = "failed";
+        run.completedAt = Date.now();
+        run.error = "Killed by parent agent";
+        // Persist failure record for killed runs (fire-and-forget, belt-defense)
+        if (deps.dataDir) {
+            suppressError(persistFailureRecord({
+                dataDir: deps.dataDir,
+                sessionKey: run.sessionKey,
+                runId,
+                task: run.task,
+                error: run.error,
+                endReason: "killed",
+                runtimeMs: run.completedAt - run.startedAt,
+            }, deps.logger), "kill-failure-record");
+        }
+        // Abort the in-flight SDK session to stop LLM API calls (best-effort)
+        if (deps.activeRunRegistry) {
+            const handle = deps.activeRunRegistry.get(run.sessionKey);
+            if (handle) {
+                handle.abort().catch((abortErr) => {
+                    deps.logger?.debug({ runId, err: abortErr }, "Sub-agent SDK abort best-effort failed");
+                });
+            }
+        }
+        // For graph-owned runs, use direct notification to graph coordinator
+        // (bypasses event bus which may have detached listener during session cleanup).
+        // CRITICAL: Do NOT emit session:sub_agent_completed AND call notifyNodeFailed --
+        // both paths call handleSubAgentCompleted synchronously, causing runningCount to go to -1.
+        if (run.graphId && run.nodeId && graphCoordinatorRef) {
+            graphCoordinatorRef.notifyNodeFailed(run.graphId, run.nodeId, runId, run.error);
+        }
+        else {
+            // Non-graph runs: use existing event bus path
+            deps.eventBus.emit("session:sub_agent_completed", {
+                runId,
+                agentId: run.agentId,
+                success: false,
+                runtimeMs: run.completedAt - run.startedAt,
+                tokensUsed: 0,
+                cost: 0,
+                timestamp: run.completedAt,
+            });
+        }
+        // Stop proxy typing on kill
+        emitProxyStop(run, runId, "killed");
+        deps.logger?.info({
+            runId, agentId: run.agentId,
+            durationMs: run.completedAt - run.startedAt,
+            task: run.task.slice(0, 200),
+        }, "Sub-agent run killed by parent");
+        // Lifecycle hook - onEnded (kill path, fire-and-forget)
+        if (deps.lifecycleHooks) {
+            deps.lifecycleHooks.onEnded({
+                runId,
+                agentId: run.agentId,
+                parentSessionKey: run.callerSessionKey ?? "unknown",
+                childSessionKey: run.sessionKey,
+                endReason: "killed",
+                runtimeMs: run.completedAt - run.startedAt,
+                tokensUsed: 0,
+                cost: 0,
+            }).catch((hookErr) => {
+                deps.logger?.warn({
+                    runId, err: hookErr,
+                    hint: "onSubagentEnded hook failed in kill path",
+                    errorKind: "internal",
+                }, "Lifecycle hook onEnded failed");
+            });
+        }
+        return { killed: true };
+    }
+    async function shutdown() {
+        clearInterval(sweepInterval);
+        // Flush any batched announcements before draining active runs
+        if (deps.batcher) {
+            await deps.batcher.shutdown();
+        }
+        // Drain dead-letter queue before shutdown
+        if (deps.deadLetterQueue) {
+            try {
+                await deps.deadLetterQueue.drain(deps.sendToChannel);
+            }
+            catch {
+                // Best-effort drain on shutdown
+            }
+        }
+        if (activePromises.size === 0)
+            return;
+        // Wait for all active runs with a 30-second timeout
+        const timeout = new Promise((resolve) => {
+            const timer = setTimeout(resolve, 30_000);
+            timer.unref();
+        });
+        await Promise.race([
+            Promise.allSettled([...activePromises]),
+            timeout,
+        ]);
+    }
+    /** Late-bind graph coordinator for direct kill cascade notification. */
+    function setGraphCoordinator(gc) {
+        graphCoordinatorRef = gc;
+    }
+    return { spawn, getRunStatus, listRuns, killRun, shutdown, setGraphCoordinator };
+}