@senpi/runtime 3.0.6-dev.runtime-phase-2.20260630134307 → 3.0.6-dev.runtime-phase-2.20260630134410

package/dist/tracking/spans/span-tracker.js

@@ -1,721 +0,0 @@
-/**
- * SpanTracker: stitches start/end hook pairs into one finalized span and
- * enqueues it on the transport. Maintains two registries:
- *
- *   - openSpans:        Map<spanKey, OpenSpan>           (LLM and tool spans)
- *   - openSubagents:    Map<childSessionKey, OpenSubagentSpan>
- *
- * Lifetimes:
- *   - LLM span:     llm_input → llm_output                (single host turn)
- *   - Tool span:    before_tool_call → after_tool_call    (single tool call)
- *   - Subagent:     subagent_spawning → … → subagent_ended (may outlive host turns)
- *
- * Orphan handling — flush spans we couldn't pair up with `data.orphan_reason`:
- *   - agent_end sweep:  any span open under (session,run) when agent_end fires
- *   - stale sweep:      anything older than STALE_TIMEOUT_MS (periodic)
- *   - shutdown drain:   anything still open at shutdown
- *
- * Never throws — errors are caught and logged.
- */
-import { randomUUID } from "node:crypto";
-import { createLogger } from "../../utils/logger.js";
-import { STALE_TIMEOUT_MS, SWEEP_INTERVAL_MS, } from "./constants.js";
-const logger = createLogger("[senpi-core][span-tracker]");
-const ADDRESS_RE = /^0x[a-f0-9]{40}$/i;
-const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function spanKeyLlm(sessionKey, runId) {
-    return `session:${sessionKey}:run:${runId}:llm`;
-}
-function spanKeyTool(sessionKey, runId, toolCallId, toolName, seq) {
-    if (toolCallId) {
-        return `session:${sessionKey}:run:${runId}:toolcall:${toolCallId}`;
-    }
-    return `session:${sessionKey}:run:${runId}:tool:${toolName}:${seq}`;
-}
-function sanitizeCorrelationId(raw) {
-    if (typeof raw !== "string")
-        return null;
-    return UUID_V4_RE.test(raw) ? raw : null;
-}
-function sanitizeAddress(raw) {
-    if (typeof raw !== "string")
-        return "";
-    const lowered = raw.toLowerCase();
-    return ADDRESS_RE.test(lowered) ? lowered : "";
-}
-function sanitizeString(raw) {
-    return typeof raw === "string" && raw.length > 0 ? raw : "";
-}
-function sanitizeUint(raw) {
-    return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 ? raw : null;
-}
-/**
- * Format a number as a fixed-6-decimal-place string for the cost_usd wire
- * field. Returns null when input is absent or non-numeric. The schema expects
- * `^\d+(\.\d{1,6})?$` — we emit canonical 6-decimal form so all wire values
- * are consistent. Negative values are rejected (return null) to match the
- * server-side validator.
- */
-function sanitizeCostUsd(raw) {
-    if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0)
-        return null;
-    return raw.toFixed(6);
-}
-export class SpanTracker {
-    transport;
-    now;
-    staleTimeoutMs;
-    openSpans = new Map();
-    openSubagents = new Map();
-    toolSeq = 0;
-    sweepTimer = null;
-    constructor(options) {
-        this.transport = options.transport;
-        this.now = options.now ?? Date.now;
-        this.staleTimeoutMs = options.staleTimeoutMs ?? STALE_TIMEOUT_MS;
-        const sweepInterval = options.sweepIntervalMs ?? SWEEP_INTERVAL_MS;
-        if (options.enableSweeper !== false) {
-            this.sweepTimer = setInterval(() => {
-                this.sweepStale();
-            }, sweepInterval);
-            if (this.sweepTimer && typeof this.sweepTimer === "object" && "unref" in this.sweepTimer) {
-                this.sweepTimer.unref();
-            }
-        }
-    }
-    // ─── LLM lifecycle (hook path) ──────────────────────────────────────────
-    openLlmSpan(input) {
-        try {
-            const key = spanKeyLlm(input.sessionKey, input.runId);
-            const existing = this.openSpans.get(key);
-            if (existing) {
-                // Silently discard the prior open span. A duplicate llm_input for the
-                // same (session, run) usually means OpenClaw's agent loop is starting
-                // a new turn (e.g., feeding back a tool result) without having fired
-                // llm_output for the previous turn — emitting an orphan row would
-                // pollute ClickHouse with partial records. We post only after the
-                // matching llm_output completes the merge.
-                logger.debug("openLlmSpan: discarding prior open span", {
-                    sessionKey: input.sessionKey,
-                    runId: input.runId,
-                });
-                this.openSpans.delete(key);
-            }
-            const id = randomUUID();
-            this.openSpans.set(key, {
-                id,
-                spanType: "llm",
-                sessionKey: input.sessionKey,
-                runId: input.runId,
-                parentSpanId: "",
-                toolCallId: "",
-                startedAt: input.startedAt ?? this.now(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                data: { input: input.input },
-                emissionSource: input.emissionSource,
-            });
-            return id;
-        }
-        catch (err) {
-            logger.warn("openLlmSpan failed", { err: errMsg(err) });
-            return "";
-        }
-    }
-    finalizeLlmSpan(input) {
-        try {
-            const key = spanKeyLlm(input.sessionKey, input.runId);
-            const open = this.openSpans.get(key);
-            if (!open) {
-                logger.warn("finalizeLlmSpan: no open span", {
-                    sessionKey: input.sessionKey,
-                    runId: input.runId,
-                });
-                return;
-            }
-            this.openSpans.delete(key);
-            const endedAt = this.now();
-            const data = {
-                ...open.data,
-                ...(input.output !== undefined ? { output: input.output } : {}),
-                ...(input.error !== undefined ? { error: errMsg(input.error) } : {}),
-            };
-            this.transport.enqueue({
-                id: open.id,
-                correlationId: sanitizeCorrelationId(input.correlationId) ?? open.correlationId,
-                sessionKey: open.sessionKey,
-                runId: open.runId,
-                childSessionKey: "",
-                toolCallId: "",
-                parentSpanId: open.parentSpanId,
-                spanType: "llm",
-                emissionSource: open.emissionSource,
-                timestamp: endedAt,
-                address: sanitizeAddress(input.address) || open.address,
-                recipeName: sanitizeString(input.recipeName) || open.recipeName,
-                runtimeId: sanitizeString(input.runtimeId) || open.runtimeId,
-                runtimeVersion: sanitizeString(input.runtimeVersion) || open.runtimeVersion,
-                startedAt: open.startedAt,
-                endedAt,
-                durationMs: Math.max(0, endedAt - open.startedAt),
-                model: sanitizeString(input.model),
-                tokensIn: sanitizeUint(input.tokensIn),
-                tokensOut: sanitizeUint(input.tokensOut),
-                costUsd: sanitizeCostUsd(input.costUsd),
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("finalizeLlmSpan failed", { err: errMsg(err) });
-        }
-    }
-    /** Returns the id of the currently-open LLM span for (session, run), or null. */
-    getActiveLlmSpanId(sessionKey, runId) {
-        return this.openSpans.get(spanKeyLlm(sessionKey, runId))?.id ?? null;
-    }
-    // ─── Tool lifecycle (hook path) ─────────────────────────────────────────
-    openToolSpan(input) {
-        try {
-            const parentSpanId = this.getActiveLlmSpanId(input.sessionKey, input.runId);
-            const seq = ++this.toolSeq;
-            const key = spanKeyTool(input.sessionKey, input.runId, input.toolCallId, input.toolName, seq);
-            // For toolCallId-keyed entries, silently discard any duplicate so we
-            // don't emit partial rows. The merge happens at after_tool_call.
-            if (input.toolCallId) {
-                const existing = this.openSpans.get(key);
-                if (existing) {
-                    logger.debug("openToolSpan: discarding prior open span", {
-                        toolCallId: input.toolCallId,
-                    });
-                    this.openSpans.delete(key);
-                }
-            }
-            const id = randomUUID();
-            this.openSpans.set(key, {
-                id,
-                spanType: "tool",
-                sessionKey: input.sessionKey,
-                runId: input.runId,
-                parentSpanId: parentSpanId ?? "",
-                toolCallId: input.toolCallId ?? "",
-                startedAt: input.startedAt ?? this.now(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                // Flat shape matches captureToolSpan (direct path) so all
-                // tool-typed rows have identical `data` layout:
-                //   { tool_name, input?, output?, error? }
-                // Downstream queries can rely on JSONExtractString(data, 'tool_name')
-                // regardless of emission_source.
-                data: {
-                    tool_name: input.toolName,
-                    ...(input.toolInput !== undefined ? { input: input.toolInput } : {}),
-                },
-                emissionSource: input.emissionSource,
-            });
-            return id;
-        }
-        catch (err) {
-            logger.warn("openToolSpan failed", { err: errMsg(err) });
-            return "";
-        }
-    }
-    finalizeToolSpan(input) {
-        try {
-            // Find by toolCallId first (most precise — bridges any runId drift).
-            let foundKey;
-            if (input.toolCallId) {
-                const exactKey = spanKeyTool(input.sessionKey, input.runId, input.toolCallId, input.toolName, 0);
-                if (this.openSpans.has(exactKey)) {
-                    foundKey = exactKey;
-                }
-            }
-            // Next, when we have a toolCallId: (session, *, toolCallId) — bridges
-            // runId drift between before_tool_call (runId=R1) and after_tool_call
-            // (runId=R2, e.g. when a fresh llm_input fired mid-tool and updated the
-            // session's lastActive runId). toolCallId is provider-stamped and unique
-            // per call, so this match is still precise — only the run scope shifts.
-            if (!foundKey && input.toolCallId) {
-                const sessionPrefix = `session:${input.sessionKey}:run:`;
-                const toolCallSuffix = `:toolcall:${input.toolCallId}`;
-                for (const key of this.openSpans.keys()) {
-                    if (key.startsWith(sessionPrefix) && key.endsWith(toolCallSuffix)) {
-                        foundKey = key;
-                        break;
-                    }
-                }
-            }
-            // Next: (session, run, toolName) prefix — happy path when runId stable
-            // and no toolCallId was issued.
-            //
-            // Without a toolCallId we can't disambiguate two same-name tools open at
-            // once. We pick the oldest by insertion order (Map iteration order) and
-            // log a warn when multiple match so the ambiguity is observable in
-            // production rather than silently mis-attributing output. If providers
-            // ever emit parallel tool calls without ids, this surfaces in the logs.
-            if (!foundKey) {
-                const prefix = `session:${input.sessionKey}:run:${input.runId}:tool:${input.toolName}:`;
-                const matches = [];
-                for (const key of this.openSpans.keys()) {
-                    if (key.startsWith(prefix))
-                        matches.push(key);
-                }
-                if (matches.length > 1) {
-                    logger.warn("finalizeToolSpan: ambiguous match (multiple same-name tools open without toolCallId); attributing to oldest", {
-                        sessionKey: input.sessionKey,
-                        runId: input.runId,
-                        toolName: input.toolName,
-                        matchCount: matches.length,
-                    });
-                }
-                foundKey = matches[0];
-            }
-            // Last resort: (session, *, toolName) — handles runId drift for spans
-            // without any toolCallId. Common with long-running exec tools. Same
-            // ambiguity rule: take the oldest matching open span and warn if more
-            // than one matched.
-            if (!foundKey && !input.toolCallId) {
-                const sessionPrefix = `session:${input.sessionKey}:run:`;
-                const toolSuffix = `:tool:${input.toolName}:`;
-                const matches = [];
-                for (const key of this.openSpans.keys()) {
-                    if (key.startsWith(sessionPrefix) && key.includes(toolSuffix)) {
-                        matches.push(key);
-                    }
-                }
-                if (matches.length > 1) {
-                    logger.warn("finalizeToolSpan: ambiguous match across runIds (multiple same-name tools open without toolCallId); attributing to oldest", {
-                        sessionKey: input.sessionKey,
-                        toolName: input.toolName,
-                        matchCount: matches.length,
-                    });
-                }
-                foundKey = matches[0];
-            }
-            if (!foundKey) {
-                // Likely already orphan-flushed by an agent_end sweep, or never opened.
-                // Downgrade to debug — warn was too noisy in practice.
-                logger.debug("finalizeToolSpan: no open span", {
-                    sessionKey: input.sessionKey,
-                    toolName: input.toolName,
-                    toolCallId: input.toolCallId,
-                });
-                return;
-            }
-            const open = this.openSpans.get(foundKey);
-            if (!open)
-                return;
-            this.openSpans.delete(foundKey);
-            const endedAt = this.now();
-            const data = { ...open.data };
-            if (input.error !== undefined) {
-                data.error = errMsg(input.error);
-            }
-            else if (input.output !== undefined) {
-                data.output =
-                    input.output && typeof input.output === "object"
-                        ? input.output
-                        : { result: input.output };
-            }
-            this.transport.enqueue({
-                id: open.id,
-                correlationId: sanitizeCorrelationId(input.correlationId) ?? open.correlationId,
-                sessionKey: open.sessionKey,
-                runId: open.runId,
-                childSessionKey: "",
-                toolCallId: open.toolCallId,
-                parentSpanId: open.parentSpanId,
-                spanType: "tool",
-                emissionSource: open.emissionSource,
-                timestamp: endedAt,
-                address: sanitizeAddress(input.address) || open.address,
-                recipeName: sanitizeString(input.recipeName) || open.recipeName,
-                runtimeId: sanitizeString(input.runtimeId) || open.runtimeId,
-                runtimeVersion: sanitizeString(input.runtimeVersion) || open.runtimeVersion,
-                startedAt: open.startedAt,
-                endedAt,
-                durationMs: input.durationMs ?? Math.max(0, endedAt - open.startedAt),
-                model: "",
-                tokensIn: null,
-                tokensOut: null,
-                costUsd: null,
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("finalizeToolSpan failed", { err: errMsg(err) });
-        }
-    }
-    // ─── Subagent lifecycle (separate registry, keyed by childSessionKey) ───
-    openSubagentSpan(input) {
-        try {
-            const existing = this.openSubagents.get(input.childSessionKey);
-            if (existing) {
-                this.enqueueSubagentOrphan(existing, "subagent_spawning_replaces_active");
-                this.openSubagents.delete(input.childSessionKey);
-            }
-            const id = randomUUID();
-            this.openSubagents.set(input.childSessionKey, {
-                id,
-                hostSessionKey: input.hostSessionKey,
-                hostRunId: input.hostRunId,
-                childSessionKey: input.childSessionKey,
-                parentSpanId: input.parentSpanId ?? "",
-                startedAt: input.startedAt ?? this.now(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                data: {
-                    input: input.input,
-                    status: "spawning",
-                },
-            });
-            return id;
-        }
-        catch (err) {
-            logger.warn("openSubagentSpan failed", { err: errMsg(err) });
-            return "";
-        }
-    }
-    /** Merge fields into an existing subagent (e.g., on _spawned, _delivery_target). Lazy-creates if missing. */
-    mergeSubagentSpan(input, context) {
-        try {
-            let open = this.openSubagents.get(input.childSessionKey);
-            if (!open) {
-                // Lazy-create: missed _spawning. Use what context we have.
-                const id = randomUUID();
-                open = {
-                    id,
-                    hostSessionKey: "",
-                    hostRunId: "",
-                    childSessionKey: input.childSessionKey,
-                    parentSpanId: "",
-                    startedAt: this.now(),
-                    correlationId: sanitizeCorrelationId(context?.correlationId),
-                    address: sanitizeAddress(context?.address),
-                    recipeName: sanitizeString(context?.recipeName),
-                    runtimeId: sanitizeString(context?.runtimeId),
-                    runtimeVersion: sanitizeString(context?.runtimeVersion),
-                    data: { status: input.status },
-                };
-                this.openSubagents.set(input.childSessionKey, open);
-            }
-            open.data.status = input.status;
-            if (input.patch) {
-                // shallow-merge any provided fields into the data root
-                for (const [k, v] of Object.entries(input.patch)) {
-                    open.data[k] = v;
-                }
-            }
-        }
-        catch (err) {
-            logger.warn("mergeSubagentSpan failed", { err: errMsg(err) });
-        }
-    }
-    finalizeSubagentSpan(input, context) {
-        try {
-            const open = this.openSubagents.get(input.childSessionKey);
-            if (!open) {
-                logger.warn("finalizeSubagentSpan: no open subagent", {
-                    childSessionKey: input.childSessionKey,
-                });
-                return;
-            }
-            this.openSubagents.delete(input.childSessionKey);
-            const endedAt = this.now();
-            const data = { ...open.data, status: input.status };
-            if (input.error !== undefined) {
-                data.output = { error: errMsg(input.error) };
-            }
-            else if (input.output !== undefined) {
-                data.output = input.output;
-            }
-            this.transport.enqueue({
-                id: open.id,
-                correlationId: sanitizeCorrelationId(context?.correlationId) ?? open.correlationId,
-                sessionKey: open.hostSessionKey,
-                runId: open.hostRunId,
-                childSessionKey: open.childSessionKey,
-                toolCallId: "",
-                parentSpanId: open.parentSpanId,
-                spanType: "subagent",
-                emissionSource: "hook",
-                timestamp: endedAt,
-                address: sanitizeAddress(context?.address) || open.address,
-                recipeName: sanitizeString(context?.recipeName) || open.recipeName,
-                runtimeId: sanitizeString(context?.runtimeId) || open.runtimeId,
-                runtimeVersion: sanitizeString(context?.runtimeVersion) || open.runtimeVersion,
-                startedAt: open.startedAt,
-                endedAt,
-                durationMs: Math.max(0, endedAt - open.startedAt),
-                model: "",
-                tokensIn: null,
-                tokensOut: null,
-                costUsd: null,
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("finalizeSubagentSpan failed", { err: errMsg(err) });
-        }
-    }
-    // ─── Agent end — emit marker + sweep orphans for this (session, run) ────
-    captureAgentEnd(input) {
-        try {
-            // Sweep orphans for this session/run.
-            const prefix = `session:${input.sessionKey}:run:${input.runId}:`;
-            const keysToSweep = [];
-            for (const key of this.openSpans.keys()) {
-                if (key.startsWith(prefix))
-                    keysToSweep.push(key);
-            }
-            for (const key of keysToSweep) {
-                const open = this.openSpans.get(key);
-                if (open) {
-                    this.enqueueOrphan(open, "agent_end_without_close");
-                    this.openSpans.delete(key);
-                }
-            }
-            // Also sweep subagents hosted by this (session, run).
-            const subKeysToSweep = [];
-            for (const [k, sub] of this.openSubagents.entries()) {
-                if (sub.hostSessionKey === input.sessionKey && sub.hostRunId === input.runId) {
-                    subKeysToSweep.push(k);
-                }
-            }
-            for (const k of subKeysToSweep) {
-                const sub = this.openSubagents.get(k);
-                if (sub) {
-                    this.enqueueSubagentOrphan(sub, "agent_end_without_close");
-                    this.openSubagents.delete(k);
-                }
-            }
-            const endedAt = this.now();
-            const data = {};
-            if (input.outcome !== undefined)
-                data.outcome = input.outcome;
-            if (input.error !== undefined)
-                data.error = errMsg(input.error);
-            this.transport.enqueue({
-                id: randomUUID(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                sessionKey: input.sessionKey,
-                runId: input.runId,
-                childSessionKey: "",
-                toolCallId: "",
-                parentSpanId: "",
-                spanType: "agent_end",
-                emissionSource: "hook",
-                timestamp: endedAt,
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                startedAt: endedAt,
-                endedAt,
-                durationMs: 0,
-                model: "",
-                tokensIn: null,
-                tokensOut: null,
-                costUsd: null,
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("captureAgentEnd failed", { err: errMsg(err) });
-        }
-    }
-    // ─── Direct (manual) emission — for non-hook paths like AnthropicLlmDecision ──
-    captureLlmSpan(input) {
-        try {
-            const data = { input: input.input };
-            if (input.output !== undefined)
-                data.output = input.output;
-            if (input.error !== undefined)
-                data.error = errMsg(input.error);
-            this.transport.enqueue({
-                id: randomUUID(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                sessionKey: input.sessionKey,
-                runId: input.runId,
-                childSessionKey: "",
-                toolCallId: "",
-                parentSpanId: input.parentSpanId ?? "",
-                spanType: "llm",
-                emissionSource: "direct",
-                timestamp: input.endedAt,
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                startedAt: input.startedAt,
-                endedAt: input.endedAt,
-                durationMs: Math.max(0, input.endedAt - input.startedAt),
-                model: sanitizeString(input.model),
-                tokensIn: sanitizeUint(input.tokensIn),
-                tokensOut: sanitizeUint(input.tokensOut),
-                costUsd: sanitizeCostUsd(input.costUsd),
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("captureLlmSpan failed", { err: errMsg(err) });
-        }
-    }
-    captureToolSpan(input) {
-        try {
-            const data = { tool_name: input.toolName };
-            if (input.input !== undefined)
-                data.input = input.input;
-            if (input.output !== undefined)
-                data.output = input.output;
-            if (input.error !== undefined)
-                data.error = errMsg(input.error);
-            this.transport.enqueue({
-                id: randomUUID(),
-                correlationId: sanitizeCorrelationId(input.correlationId),
-                sessionKey: input.sessionKey,
-                runId: input.runId,
-                childSessionKey: "",
-                toolCallId: input.toolCallId ?? "",
-                parentSpanId: input.parentSpanId ?? "",
-                spanType: "tool",
-                emissionSource: "direct",
-                timestamp: input.endedAt,
-                address: sanitizeAddress(input.address),
-                recipeName: sanitizeString(input.recipeName),
-                runtimeId: sanitizeString(input.runtimeId),
-                runtimeVersion: sanitizeString(input.runtimeVersion),
-                startedAt: input.startedAt,
-                endedAt: input.endedAt,
-                durationMs: Math.max(0, input.endedAt - input.startedAt),
-                model: "",
-                tokensIn: null,
-                tokensOut: null,
-                costUsd: null,
-                data,
-            });
-        }
-        catch (err) {
-            logger.warn("captureToolSpan failed", { err: errMsg(err) });
-        }
-    }
-    // ─── Maintenance ────────────────────────────────────────────────────────
-    sweepStale() {
-        try {
-            const cutoff = this.now() - this.staleTimeoutMs;
-            const keys = [];
-            for (const [k, open] of this.openSpans.entries()) {
-                if (open.startedAt < cutoff)
-                    keys.push(k);
-            }
-            for (const k of keys) {
-                const open = this.openSpans.get(k);
-                if (open) {
-                    this.enqueueOrphan(open, "stale_timeout");
-                    this.openSpans.delete(k);
-                }
-            }
-            const subKeys = [];
-            for (const [k, sub] of this.openSubagents.entries()) {
-                if (sub.startedAt < cutoff)
-                    subKeys.push(k);
-            }
-            for (const k of subKeys) {
-                const sub = this.openSubagents.get(k);
-                if (sub) {
-                    this.enqueueSubagentOrphan(sub, "stale_timeout");
-                    this.openSubagents.delete(k);
-                }
-            }
-        }
-        catch (err) {
-            logger.warn("sweepStale failed", { err: errMsg(err) });
-        }
-    }
-    async shutdown() {
-        if (this.sweepTimer) {
-            clearInterval(this.sweepTimer);
-            this.sweepTimer = null;
-        }
-        // Drain remaining open spans as orphans.
-        for (const [k, open] of this.openSpans.entries()) {
-            this.enqueueOrphan(open, "shutdown");
-            this.openSpans.delete(k);
-        }
-        for (const [k, sub] of this.openSubagents.entries()) {
-            this.enqueueSubagentOrphan(sub, "shutdown");
-            this.openSubagents.delete(k);
-        }
-        await this.transport.shutdown();
-    }
-    // ─── Internal: orphan enqueue helpers ───────────────────────────────────
-    enqueueOrphan(open, reason) {
-        const endedAt = this.now();
-        const data = { ...open.data, orphan_reason: reason };
-        const span = {
-            id: open.id,
-            correlationId: open.correlationId,
-            sessionKey: open.sessionKey,
-            runId: open.runId,
-            childSessionKey: "",
-            toolCallId: open.toolCallId,
-            parentSpanId: open.parentSpanId,
-            spanType: open.spanType,
-            emissionSource: open.emissionSource,
-            timestamp: endedAt,
-            address: open.address,
-            recipeName: open.recipeName,
-            runtimeId: open.runtimeId,
-            runtimeVersion: open.runtimeVersion,
-            startedAt: open.startedAt,
-            endedAt,
-            durationMs: Math.max(0, endedAt - open.startedAt),
-            model: "",
-            tokensIn: null,
-            tokensOut: null,
-            costUsd: null,
-            data,
-        };
-        this.transport.enqueue(span);
-    }
-    enqueueSubagentOrphan(open, reason) {
-        const endedAt = this.now();
-        const data = { ...open.data, orphan_reason: reason };
-        this.transport.enqueue({
-            id: open.id,
-            correlationId: open.correlationId,
-            sessionKey: open.hostSessionKey,
-            runId: open.hostRunId,
-            childSessionKey: open.childSessionKey,
-            toolCallId: "",
-            parentSpanId: open.parentSpanId,
-            spanType: "subagent",
-            emissionSource: "hook",
-            timestamp: endedAt,
-            address: open.address,
-            recipeName: open.recipeName,
-            runtimeId: open.runtimeId,
-            runtimeVersion: open.runtimeVersion,
-            startedAt: open.startedAt,
-            endedAt,
-            durationMs: Math.max(0, endedAt - open.startedAt),
-            model: "",
-            tokensIn: null,
-            tokensOut: null,
-            costUsd: null,
-            data,
-        });
-    }
-}
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-//# sourceMappingURL=span-tracker.js.map