@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/telemetry/agent-integrations/opencode-integration.js

@@ -0,0 +1,72 @@
+const OPENCODE_BINARIES = ["opencode"];
+/**
+ * Detects `opencode run ...` invocations and enables OpenCode's
+ * native OpenTelemetry support, routing to loop-task's endpoint.
+ */
+export class OpenCodeTelemetryIntegration {
+    constructor() {
+        this.id = "opencode";
+    }
+    matches(command, args) {
+        const basename = command.split("/").pop()?.replace(/\.exe$/, "").toLowerCase() ?? "";
+        return OPENCODE_BINARIES.includes(basename) && args[0] === "run";
+    }
+    prepare(invocation, _context) {
+        const env = { ...invocation.env };
+        // Enable OpenCode's experimental OpenTelemetry
+        env.OPENCODE_EXPERIMENTAL_OPEN_TELEMETRY = "true";
+        // Adapt the OTLP endpoint/proprotocol from the parent context
+        // OpenCode currently reads the standard OTEL_* environment variables
+        // which are already set by the adapter's prepareChildProcess
+        // We just need to make sure the integration is activated.
+        return { command: invocation.command, args: [...invocation.args], env };
+    }
+    parseUsage(result) {
+        if (result.exitCode !== 0 || !result.stdout)
+            return undefined;
+        try {
+            // OpenCode may output JSON with --format json
+            // Try to parse structured output for usage data
+            const lines = result.stdout.trim().split("\n");
+            const lastLine = lines[lines.length - 1];
+            if (!lastLine)
+                return undefined;
+            const parsed = JSON.parse(lastLine);
+            if (typeof parsed !== "object" || parsed === null)
+                return undefined;
+            const usage = {};
+            if (typeof parsed.inputTokens === "number")
+                usage.inputTokens = parsed.inputTokens;
+            if (typeof parsed.input_tokens === "number")
+                usage.inputTokens = parsed.input_tokens;
+            if (typeof parsed.outputTokens === "number")
+                usage.outputTokens = parsed.outputTokens;
+            if (typeof parsed.output_tokens === "number")
+                usage.outputTokens = parsed.output_tokens;
+            if (typeof parsed.cacheReadTokens === "number")
+                usage.cacheReadTokens = parsed.cacheReadTokens;
+            if (typeof parsed.cache_read_tokens === "number")
+                usage.cacheReadTokens = parsed.cache_read_tokens;
+            if (typeof parsed.cacheWriteTokens === "number")
+                usage.cacheWriteTokens = parsed.cacheWriteTokens;
+            if (typeof parsed.cache_write_tokens === "number")
+                usage.cacheWriteTokens = parsed.cache_write_tokens;
+            if (typeof parsed.cost === "number")
+                usage.costUsd = parsed.cost;
+            if (typeof parsed.cost_usd === "number")
+                usage.costUsd = parsed.cost_usd;
+            if (typeof parsed.model === "string")
+                usage.model = parsed.model;
+            if (typeof parsed.provider === "string")
+                usage.provider = parsed.provider;
+            if (typeof parsed.sessionId === "string")
+                usage.sessionId = parsed.sessionId;
+            if (Object.keys(usage).length === 0)
+                return undefined;
+            return usage;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/daemon/telemetry/index.js

@@ -0,0 +1,6 @@
+export { TelemetryManager } from "./telemetry-manager.js";
+export { NoopTelemetryAdapter } from "./noop-telemetry-adapter.js";
+export { OpenTelemetryAdapter } from "./open-telemetry-adapter.js";
+export * from "./telemetry-types.js";
+export * from "./telemetry-redaction.js";
+export * from "./agent-integrations/index.js";

package/dist/daemon/telemetry/noop-telemetry-adapter.js

@@ -0,0 +1,53 @@
+class NoopSpan {
+    setAttribute() { }
+    setAttributes() { }
+    recordError() { }
+    ok() { }
+    end() { }
+    getTraceContext() {
+        return {};
+    }
+}
+/**
+ * No-op telemetry adapter. Used when telemetry is disabled or
+ * when no endpoint is configured. All operations are safe no-ops.
+ */
+export class NoopTelemetryAdapter {
+    constructor(statusOverrides) {
+        this.status = {
+            enabled: false,
+            exporterConfigured: false,
+            endpoint: undefined,
+            protocol: "http/protobuf",
+            serviceName: "loop-task",
+            autoInstrumentAgents: false,
+            captureContent: false,
+            captureCommandOutput: false,
+            exporterState: "disabled",
+            ...statusOverrides,
+        };
+    }
+    startLoop() {
+        return new NoopSpan();
+    }
+    startTask() {
+        return new NoopSpan();
+    }
+    startCommand() {
+        return new NoopSpan();
+    }
+    recordRetry() { }
+    recordFailure() { }
+    recordAgentUsage() { }
+    prepareChildProcess(_invocation, _context, _integrationOverride) {
+        return { env: {} };
+    }
+    getStatus() {
+        return { ...this.status };
+    }
+    updateStatus(partial) {
+        this.status = { ...this.status, ...partial };
+    }
+    async flush() { }
+    async shutdown() { }
+}

package/dist/daemon/telemetry/open-telemetry-adapter.js

@@ -0,0 +1,464 @@
+import { SPAN_NAMES, CORRELATION_KEYS, METRIC_NAMES } from "./telemetry-types.js";
+import { detectAgentIntegration, getAgentIntegrations } from "./agent-integrations/index.js";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPTraceExporter as OTLPTraceExporterGrpc } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPMetricExporter as OTLPMetricExporterGrpc } from "@opentelemetry/exporter-metrics-otlp-grpc";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { trace, context, propagation, metrics, SpanStatusCode, SpanKind } from "@opentelemetry/api";
+import { daemonLog } from "../daemon-log.js";
+class OtelSpan {
+    constructor(span, ctx, onEnd) {
+        this.span = span;
+        this.ctx = ctx;
+        this.ended = false;
+        this.onEnd = onEnd;
+        this.startTime = Date.now();
+    }
+    setAttribute(key, value) {
+        this.span.setAttribute(key, value);
+    }
+    setAttributes(attrs) {
+        for (const [k, v] of Object.entries(attrs)) {
+            this.span.setAttribute(k, v);
+        }
+    }
+    recordError(error) {
+        if (error instanceof Error) {
+            this.span.recordException(error);
+        }
+        else {
+            this.span.recordException(String(error));
+        }
+        this.span.setStatus({ code: SpanStatusCode.ERROR, message: error instanceof Error ? error.message : String(error) });
+    }
+    ok() {
+        this.span.setStatus({ code: SpanStatusCode.OK });
+        this.span.end();
+        this.emitMetric("ok");
+    }
+    end(status) {
+        if (status === "error") {
+            this.span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+        else if (status === "cancelled") {
+            this.span.setStatus({ code: SpanStatusCode.ERROR, message: "cancelled" });
+        }
+        this.span.end();
+        this.emitMetric(status ?? "ok");
+    }
+    getTraceContext() {
+        const carrier = {};
+        propagation.inject(this.ctx, carrier, {
+            set: (c, k, v) => { c[k] = v; },
+        });
+        return {
+            traceParent: carrier.traceparent,
+            traceState: carrier.tracestate,
+        };
+    }
+    emitMetric(status) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        if (this.onEnd) {
+            this.onEnd(Date.now() - this.startTime, status);
+        }
+    }
+}
+/**
+ * OpenTelemetry SDK-backed adapter. Manages the full SDK lifecycle
+ * including tracer, meter, and exporters.
+ */
+export class OpenTelemetryAdapter {
+    constructor(settings) {
+        this.sdk = null;
+        this.tracerProvider = null;
+        this.settings = settings;
+        this.tracer = trace.getTracer("loop-task");
+        this.meter = metrics.getMeter("loop-task");
+        this.status = {
+            enabled: settings.telemetryEnabled,
+            exporterConfigured: !!settings.telemetryEndpoint,
+            endpoint: settings.telemetryEndpoint,
+            protocol: settings.telemetryProtocol,
+            serviceName: settings.telemetryServiceName,
+            autoInstrumentAgents: settings.telemetryAutoInstrumentAgents,
+            captureContent: settings.telemetryCaptureContent,
+            captureCommandOutput: settings.telemetryCaptureCommandOutput,
+            exporterState: this.resolveExporterState(settings),
+        };
+        // Initialize metric instruments (always created — no-op when no SDK)
+        this.runCounter = this.meter.createCounter(METRIC_NAMES.RUNS);
+        this.runDurationHistogram = this.meter.createHistogram(METRIC_NAMES.RUN_DURATION);
+        this.taskCounter = this.meter.createCounter(METRIC_NAMES.TASKS);
+        this.taskDurationHistogram = this.meter.createHistogram(METRIC_NAMES.TASK_DURATION);
+        this.taskRetriesCounter = this.meter.createCounter(METRIC_NAMES.TASK_RETRIES);
+        this.commandCounter = this.meter.createCounter(METRIC_NAMES.COMMANDS);
+        this.commandDurationHistogram = this.meter.createHistogram(METRIC_NAMES.COMMAND_DURATION);
+        this.agentExecCounter = this.meter.createCounter(METRIC_NAMES.AGENT_EXECUTIONS);
+        this.agentDurationHistogram = this.meter.createHistogram(METRIC_NAMES.AGENT_DURATION);
+        this.agentInputTokensCounter = this.meter.createCounter(METRIC_NAMES.AGENT_INPUT_TOKENS);
+        this.agentOutputTokensCounter = this.meter.createCounter(METRIC_NAMES.AGENT_OUTPUT_TOKENS);
+        this.agentCacheReadTokensCounter = this.meter.createCounter(METRIC_NAMES.AGENT_CACHE_READ_TOKENS);
+        this.agentCacheWriteTokensCounter = this.meter.createCounter(METRIC_NAMES.AGENT_CACHE_WRITE_TOKENS);
+        this.agentCostCounter = this.meter.createCounter(METRIC_NAMES.AGENT_COST);
+        this.failureCounter = this.meter.createCounter(METRIC_NAMES.FAILURES);
+        if (settings.telemetryEnabled && settings.telemetryEndpoint) {
+            this.initializeSdk(settings);
+        }
+    }
+    resolveExporterState(settings) {
+        if (!settings.telemetryEnabled)
+            return "disabled";
+        if (!settings.telemetryEndpoint)
+            return "not-configured";
+        return "configured";
+    }
+    initializeSdk(settings) {
+        try {
+            const resource = resourceFromAttributes({
+                [ATTR_SERVICE_NAME]: settings.telemetryServiceName,
+                [ATTR_SERVICE_VERSION]: "2.2.6",
+            });
+            const isGrpc = settings.telemetryProtocol === "grpc";
+            const headers = this.resolveHeaders();
+            const endpoint = settings.telemetryEndpoint ?? "";
+            const tracesUrl = endpoint.endsWith("/v1/traces")
+                ? endpoint
+                : `${endpoint}/v1/traces`;
+            const metricsUrl = endpoint.endsWith("/v1/metrics")
+                ? endpoint
+                : `${endpoint}/v1/metrics`;
+            const traceExporter = isGrpc
+                ? new OTLPTraceExporterGrpc({ url: settings.telemetryEndpoint })
+                : new OTLPTraceExporter({ url: tracesUrl, headers });
+            const spanProcessor = new BatchSpanProcessor(traceExporter, {
+                maxQueueSize: 2048,
+                scheduledDelayMillis: 5000,
+                maxExportBatchSize: 512,
+            });
+            const tracerProvider = new NodeTracerProvider({
+                resource,
+                spanProcessors: [spanProcessor],
+            });
+            this.tracerProvider = tracerProvider;
+            tracerProvider.register();
+            const metricExporter = isGrpc
+                ? new OTLPMetricExporterGrpc({ url: settings.telemetryEndpoint })
+                : new OTLPMetricExporter({ url: metricsUrl, headers });
+            const metricReader = new PeriodicExportingMetricReader({
+                exporter: metricExporter,
+                exportIntervalMillis: 30_000,
+            });
+            this.sdk = new NodeSDK({
+                resource,
+                metricReader,
+                instrumentations: [],
+            });
+            this.sdk.start();
+            this.tracer = trace.getTracer(settings.telemetryServiceName);
+            this.status.exporterState = "configured";
+            daemonLog(`telemetry: SDK initialized, endpoint=${settings.telemetryEndpoint}`);
+        }
+        catch (err) {
+            daemonLog(`telemetry: SDK initialization failed: ${String(err)}`);
+            this.status.exporterState = "unavailable";
+            this.lastExportError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    resolveHeaders() {
+        const headers = {};
+        const envHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS
+            ?? process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS;
+        if (envHeaders) {
+            for (const pair of envHeaders.split(",")) {
+                const [k, v] = pair.split("=", 2);
+                if (k && v)
+                    headers[k.trim()] = v.trim();
+            }
+        }
+        return headers;
+    }
+    resolveEndpoint() {
+        return this.settings.telemetryEndpoint
+            ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    }
+    resolveProtocol() {
+        const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
+        if (envProtocol === "grpc")
+            return "grpc";
+        if (envProtocol === "http/protobuf")
+            return "http/protobuf";
+        return this.settings.telemetryProtocol;
+    }
+    startLoop(input) {
+        const span = this.tracer.startSpan(SPAN_NAMES.LOOP_RUN, { kind: SpanKind.SERVER });
+        span.setAttributes({
+            [CORRELATION_KEYS.RUN_ID]: input.runId,
+            [CORRELATION_KEYS.LOOP_ID]: input.loopId,
+            [CORRELATION_KEYS.LOOP_NAME]: input.loopName,
+            ...(input.projectId ? { [CORRELATION_KEYS.PROJECT_ID]: input.projectId } : {}),
+            ...(input.projectName ? { [CORRELATION_KEYS.PROJECT_NAME]: input.projectName } : {}),
+        });
+        const ctx = trace.setSpan(context.active(), span);
+        this.runCounter.add(1, { "loop_task.loop.id": input.loopId, "loop_task.loop.name": input.loopName });
+        return new OtelSpan(span, ctx, (durationMs, status) => {
+            this.runDurationHistogram.record(durationMs, { "loop_task.loop.id": input.loopId, status });
+            if (status === "error")
+                this.failureCounter.add(1, { "loop_task.span": "loop" });
+        });
+    }
+    startTask(input, parent) {
+        const parentCtx = parent instanceof OtelSpan ? parent["ctx"] : context.active();
+        const span = this.tracer.startSpan(SPAN_NAMES.TASK_EXECUTE, { kind: SpanKind.CONSUMER }, parentCtx);
+        span.setAttributes({
+            [CORRELATION_KEYS.RUN_ID]: input.runId,
+            [CORRELATION_KEYS.LOOP_ID]: input.loopId,
+            [CORRELATION_KEYS.LOOP_NAME]: input.loopName,
+            [CORRELATION_KEYS.TASK_ID]: input.taskId,
+            [CORRELATION_KEYS.TASK_NAME]: input.taskName,
+            ...(input.projectId ? { [CORRELATION_KEYS.PROJECT_ID]: input.projectId } : {}),
+            ...(input.projectName ? { [CORRELATION_KEYS.PROJECT_NAME]: input.projectName } : {}),
+        });
+        const ctx = trace.setSpan(parentCtx, span);
+        this.taskCounter.add(1, { "loop_task.task.name": input.taskName });
+        return new OtelSpan(span, ctx, (durationMs, status) => {
+            this.taskDurationHistogram.record(durationMs, { "loop_task.task.name": input.taskName, status });
+            if (status === "error")
+                this.failureCounter.add(1, { "loop_task.span": "task" });
+        });
+    }
+    startCommand(input, parent) {
+        const parentCtx = parent instanceof OtelSpan ? parent["ctx"] : context.active();
+        const span = this.tracer.startSpan(SPAN_NAMES.COMMAND_EXECUTE, { kind: SpanKind.CLIENT }, parentCtx);
+        span.setAttributes({
+            "process.executable.name": input.command,
+            "loop_task.command.argument_count": input.argumentCount,
+            [CORRELATION_KEYS.RUN_ID]: input.runId,
+            [CORRELATION_KEYS.LOOP_ID]: input.loopId,
+            ...(input.taskId ? { [CORRELATION_KEYS.TASK_ID]: input.taskId } : {}),
+            ...(input.taskName ? { [CORRELATION_KEYS.TASK_NAME]: input.taskName } : {}),
+            ...(input.cwd ? { "loop_task.command.cwd": input.cwd } : {}),
+            ...(input.integrationId ? { [CORRELATION_KEYS.AGENT_INTEGRATION]: input.integrationId } : {}),
+        });
+        if (this.settings.telemetryCaptureContent && input.commandLine) {
+            span.setAttribute("loop_task.command.full", input.commandLine);
+        }
+        const ctx = trace.setSpan(parentCtx, span);
+        this.commandCounter.add(1, { "process.executable.name": input.command });
+        return new OtelSpan(span, ctx, (durationMs, status) => {
+            this.commandDurationHistogram.record(durationMs, { "process.executable.name": input.command, status });
+            if (status === "error")
+                this.failureCounter.add(1, { "loop_task.span": "command" });
+        });
+    }
+    recordRetry(input) {
+        const activeSpan = trace.getActiveSpan();
+        if (activeSpan) {
+            activeSpan.addEvent("retry", {
+                "loop_task.retry.attempt": input.attempt,
+                "loop_task.retry.max_attempts": input.maxAttempts,
+                [CORRELATION_KEYS.RUN_ID]: input.runId,
+                [CORRELATION_KEYS.LOOP_ID]: input.loopId,
+                ...(input.taskId ? { [CORRELATION_KEYS.TASK_ID]: input.taskId } : {}),
+            });
+        }
+        this.taskRetriesCounter.add(1, {
+            ...(input.taskId ? { "loop_task.task.id": input.taskId } : {}),
+        });
+    }
+    recordFailure(error, attributes) {
+        const activeSpan = trace.getActiveSpan();
+        if (activeSpan) {
+            if (error instanceof Error) {
+                activeSpan.recordException(error);
+            }
+            activeSpan.setStatus({ code: SpanStatusCode.ERROR, message: error instanceof Error ? error.message : String(error) });
+            if (attributes) {
+                for (const [k, v] of Object.entries(attributes)) {
+                    activeSpan.setAttribute(k, v);
+                }
+            }
+        }
+    }
+    recordAgentUsage(input, parent) {
+        const activeSpan = parent instanceof OtelSpan ? parent["span"] : trace.getActiveSpan();
+        if (!activeSpan)
+            return;
+        if (input.inputTokens !== undefined) {
+            activeSpan.setAttribute("gen_ai.usage.input_tokens", input.inputTokens);
+            this.agentInputTokensCounter.add(input.inputTokens, {
+                ...(input.integration ? { "loop_task.agent.integration": input.integration } : {}),
+                ...(input.model ? { "gen_ai.request.model": input.model } : {}),
+            });
+        }
+        if (input.outputTokens !== undefined) {
+            activeSpan.setAttribute("gen_ai.usage.output_tokens", input.outputTokens);
+            this.agentOutputTokensCounter.add(input.outputTokens, {
+                ...(input.integration ? { "loop_task.agent.integration": input.integration } : {}),
+                ...(input.model ? { "gen_ai.request.model": input.model } : {}),
+            });
+        }
+        if (input.cacheReadTokens !== undefined) {
+            activeSpan.setAttribute("loop_task.agent.cache_read_tokens", input.cacheReadTokens);
+            this.agentCacheReadTokensCounter.add(input.cacheReadTokens);
+        }
+        if (input.cacheWriteTokens !== undefined) {
+            activeSpan.setAttribute("loop_task.agent.cache_write_tokens", input.cacheWriteTokens);
+            this.agentCacheWriteTokensCounter.add(input.cacheWriteTokens);
+        }
+        if (input.costUsd !== undefined) {
+            activeSpan.setAttribute("loop_task.agent.cost_usd", input.costUsd);
+            this.agentCostCounter.add(input.costUsd);
+        }
+        if (input.provider) {
+            activeSpan.setAttribute("gen_ai.provider.name", input.provider);
+        }
+        if (input.model) {
+            activeSpan.setAttribute("gen_ai.request.model", input.model);
+        }
+    }
+    prepareChildProcess(invocation, childContext, integrationOverride) {
+        const env = {};
+        const endpoint = this.resolveEndpoint();
+        const protocol = this.resolveProtocol();
+        if (!this.settings.telemetryEnabled || !endpoint) {
+            return { env };
+        }
+        if (childContext.traceParent) {
+            env.TRACEPARENT = childContext.traceParent;
+            if (childContext.traceState) {
+                env.TRACESTATE = childContext.traceState;
+            }
+        }
+        env.OTEL_EXPORTER_OTLP_ENDPOINT = endpoint;
+        env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT = endpoint;
+        env.OTEL_EXPORTER_OTLP_PROTOCOL = protocol;
+        env.OTEL_TRACES_EXPORTER = "otlp";
+        const authHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS
+            ?? process.env.OTEL_EXPORTER_OTLP_TRACES_HEADERS;
+        if (authHeaders) {
+            env.OTEL_EXPORTER_OTLP_HEADERS = authHeaders;
+        }
+        const correlationAttrs = {
+            [CORRELATION_KEYS.RUN_ID]: childContext.runId,
+            [CORRELATION_KEYS.LOOP_ID]: childContext.loopId,
+        };
+        if (childContext.taskId)
+            correlationAttrs[CORRELATION_KEYS.TASK_ID] = childContext.taskId;
+        if (childContext.projectId)
+            correlationAttrs[CORRELATION_KEYS.PROJECT_ID] = childContext.projectId;
+        const mergedResourceAttrs = this.mergeResourceAttributes(process.env.OTEL_RESOURCE_ATTRIBUTES, correlationAttrs);
+        env.OTEL_RESOURCE_ATTRIBUTES = mergedResourceAttrs;
+        // Apply agent-specific integrations when auto-instrumentation is enabled
+        let integrationId;
+        if (this.settings.telemetryAutoInstrumentAgents || integrationOverride) {
+            // Per-task override takes precedence
+            if (integrationOverride === "none") {
+                // Explicitly disable agent integration — no agent-specific env
+                integrationId = undefined;
+            }
+            else if (integrationOverride && integrationOverride !== "auto") {
+                // Force a specific integration: opencode, claude-code, or generic
+                if (integrationOverride === "generic") {
+                    // Generic: no agent-specific activation, just the base OTLP env
+                    integrationId = undefined;
+                }
+                else {
+                    const allIntegrations = [
+                        ...getAgentIntegrations(),
+                    ];
+                    const target = allIntegrations.find((i) => i.id === integrationOverride);
+                    if (target) {
+                        integrationId = target.id;
+                        const prepared = target.prepare({ ...invocation, env: { ...invocation.env, ...env } }, childContext);
+                        Object.assign(env, prepared.env);
+                    }
+                }
+            }
+            else {
+                // Auto-detect
+                const integration = detectAgentIntegration(invocation.command, invocation.args);
+                if (integration) {
+                    integrationId = integration.id;
+                    const prepared = integration.prepare({ ...invocation, env: { ...invocation.env, ...env } }, childContext);
+                    Object.assign(env, prepared.env);
+                }
+            }
+        }
+        return { env, integrationId };
+    }
+    mergeResourceAttributes(existing, additions = {}) {
+        const map = new Map();
+        if (existing) {
+            for (const pair of existing.split(",")) {
+                const [k, v] = pair.split("=", 2);
+                if (k && v)
+                    map.set(k.trim(), v.trim());
+            }
+        }
+        for (const [k, v] of Object.entries(additions)) {
+            map.set(k, v);
+        }
+        return [...map.entries()].map(([k, v]) => `${k}=${v}`).join(",");
+    }
+    getStatus() {
+        return { ...this.status, lastSuccessfulExportAt: this.lastSuccessfulExport, lastExportError: this.lastExportError };
+    }
+    async flush() {
+        if (!this.sdk)
+            return;
+        try {
+            const flushes = [];
+            if (this.tracerProvider) {
+                flushes.push(this.tracerProvider.forceFlush());
+            }
+            const sdkInternals = this.sdk;
+            if (typeof sdkInternals._meterProvider?.forceFlush === "function") {
+                flushes.push(sdkInternals._meterProvider.forceFlush());
+            }
+            if (flushes.length === 0) {
+                throw new Error("OpenTelemetry SDK providers do not support forceFlush");
+            }
+            await Promise.all(flushes);
+            daemonLog("telemetry: SDK flushed");
+            this.lastSuccessfulExport = new Date().toISOString();
+            if (this.status.exporterState !== "healthy") {
+                this.status.exporterState = "healthy";
+            }
+        }
+        catch (err) {
+            daemonLog(`telemetry: flush failed: ${String(err)}`);
+            this.lastExportError = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+    }
+    async shutdown() {
+        if (this.tracerProvider) {
+            try {
+                await this.tracerProvider.forceFlush();
+                await this.tracerProvider.shutdown();
+            }
+            catch {
+                // best effort
+            }
+            this.tracerProvider = null;
+        }
+        if (!this.sdk)
+            return;
+        try {
+            await this.sdk.shutdown();
+            daemonLog("telemetry: SDK shut down");
+        }
+        catch (err) {
+            daemonLog(`telemetry: shutdown error: ${String(err)}`);
+        }
+        this.sdk = null;
+    }
+}