@volcengine/tls-observer-claude-code 0.0.1

package/dist/index.js

@@ -0,0 +1,1982 @@
+import { homedir, hostname, networkInterfaces, userInfo } from "node:os";
+import { tlsOpenapi } from "@volcengine/openapi";
+import { createHash, randomUUID } from "node:crypto";
+import * as __rspack_external_node_fs_promises_153e37e0 from "node:fs/promises";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+function firstEnv(...names) {
+    for (const name of names){
+        const value = process.env[name];
+        if ('string' == typeof value && '' !== value.trim()) return value.trim();
+    }
+}
+function envFlag(name, defaultValue = false) {
+    const value = process.env[name];
+    if (void 0 === value || '' === value) return defaultValue;
+    return /^(1|true|yes|y|on)$/i.test(value);
+}
+function envDisabled(name) {
+    return /^(0|false|no|n|off)$/i.test(process.env[name] ?? '');
+}
+function envPositiveInteger(name, fallback) {
+    const value = Number.parseInt(process.env[name] ?? '', 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function defaultDataRoot() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'plugins', 'data', 'tls-observer-claude-code');
+}
+function defaultEnvFile() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.claude', 'tls-observer-claude-code.env');
+}
+function parseEnvValue(raw) {
+    const value = raw.trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\'/g, "'");
+    return value;
+}
+function loadEnvFile(filePath) {
+    const target = filePath || firstEnv('CLAUDE_CODE_TLS_ENV_FILE') || defaultEnvFile();
+    let text;
+    try {
+        text = __rspack_external_node_fs_5ea92f0c.readFileSync(target, 'utf8');
+    } catch  {
+        return false;
+    }
+    for (const rawLine of text.split(/\r?\n/)){
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) continue;
+        const normalized = line.startsWith('export ') ? line.slice(7).trim() : line;
+        const match = normalized.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+        if (!match) continue;
+        const [, key, rawValue] = match;
+        process.env[key] ??= parseEnvValue(rawValue);
+    }
+    return true;
+}
+function loadConfig() {
+    loadEnvFile();
+    const dataRoot = firstEnv('CLAUDE_CODE_TLS_DATA_ROOT', 'CLAUDE_PLUGIN_DATA') || defaultDataRoot();
+    const serviceName = firstEnv('CLAUDE_CODE_OTEL_SERVICE_NAME') || "claude-code-transcript-hook";
+    const exportRetries = Math.min(envPositiveInteger('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_RETRIES', 1), 3);
+    return {
+        enabled: !envDisabled('CLAUDE_CODE_TLS_EXPORT'),
+        dataRoot,
+        stateFilePath: firstEnv('CLAUDE_CODE_TLS_STATE_FILE') || __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'claude-code-state.json'),
+        sendLogsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'send'),
+        artifactsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'artifacts'),
+        diagnosticLogMaxBytes: envPositiveInteger('CLAUDE_CODE_TLS_DIAGNOSTIC_LOG_MAX_BYTES', 5242880),
+        captureContent: !envDisabled('CLAUDE_CODE_TLS_CAPTURE_CONTENT'),
+        debugArtifacts: envFlag('CLAUDE_CODE_TLS_DEBUG_ARTIFACTS', false),
+        serviceName,
+        serviceInstanceId: `${serviceName}@${hostname()}:${process.pid}`,
+        tlsEndpoint: firstEnv('CLAUDE_CODE_TLS_ENDPOINT', 'TRACE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        otelEndpoint: firstEnv('CLAUDE_CODE_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'),
+        region: firstEnv('CLAUDE_CODE_TLS_REGION', 'TLS_REGION'),
+        traceTopicId: firstEnv('CLAUDE_CODE_TLS_TRACE_TOPIC_ID', 'CLAUDE_CODE_TLS_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        apiKey: firstEnv('CLAUDE_CODE_TLS_API_KEY', 'TLS_API_KEY'),
+        ak: firstEnv('CLAUDE_CODE_TLS_AK', 'TLS_AK'),
+        sk: firstEnv('CLAUDE_CODE_TLS_SK', 'TLS_SK'),
+        authMode: 'resource' === firstEnv('CLAUDE_CODE_TLS_AUTH_MODE', 'TLS_AUTH_MODE') ? 'resource' : 'header',
+        exportTimeoutMs: envPositiveInteger('CLAUDE_CODE_TLS_EXPORT_TIMEOUT_MS', 20000),
+        exportTimeoutRetries: exportRetries
+    };
+}
+function localIdentityMetadata() {
+    return {
+        'user.name': userInfo().username
+    };
+}
+function safeJsonStringify(value, fallback = '{}') {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (_key, item)=>{
+            if (item && 'object' == typeof item) {
+                if (seen.has(item)) return '[Circular]';
+                seen.add(item);
+            }
+            return item;
+        }) ?? fallback;
+    } catch  {
+        return fallback;
+    }
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item])=>null != item && '' !== item));
+}
+const TLS_ANONYMOUS_IDENTITY_HEADER = 'x-tls-anonymous-identity';
+const NO_RETRY_STATUS_CODES = [
+    400,
+    401,
+    403,
+    404
+];
+const producerEntries = new Map();
+function firstExternalIpv4() {
+    for (const items of Object.values(networkInterfaces()))for (const item of items ?? [])if ('IPv4' === item.family && !item.internal && item.address) return item.address;
+    return '127.0.0.1';
+}
+function normalizeProducerEndpoint(endpoint) {
+    const raw = endpoint.trim();
+    if (!raw) return raw;
+    try {
+        const url = new URL(/^https?:\/\//.test(raw) ? raw : `https://${raw}`);
+        return url.hostname || raw;
+    } catch  {
+        return raw.replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/:\d+$/, '');
+    }
+}
+function producerKey(config) {
+    return JSON.stringify({
+        endpoint: normalizeProducerEndpoint(config.endpoint),
+        region: config.region,
+        apiKey: config.apiKey || '',
+        ak: config.ak || '',
+        sk: config.sk || ''
+    });
+}
+function timeoutError(label, timeoutMs) {
+    return new Error(`${label} timed out after ${timeoutMs}ms`);
+}
+function withTimeout(promise, timeoutMs, label) {
+    const effectiveTimeoutMs = Number.isFinite(timeoutMs) && Number(timeoutMs) > 0 ? Math.trunc(Number(timeoutMs)) : 20000;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(timeoutError(label, effectiveTimeoutMs)), effectiveTimeoutMs);
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function getProducer(config) {
+    const key = producerKey(config);
+    const existing = producerEntries.get(key);
+    if (existing) return existing;
+    const producerConfig = tlsOpenapi.Producer.getDefaultProducerConfig();
+    producerConfig.Endpoint = normalizeProducerEndpoint(config.endpoint);
+    producerConfig.Region = config.region;
+    producerConfig.NoRetryStatusCodeList = NO_RETRY_STATUS_CODES;
+    if (config.apiKey) {
+        producerConfig.AccessKeyID = '';
+        producerConfig.AccessKeySecret = '';
+        producerConfig.Headers = {
+            [TLS_ANONYMOUS_IDENTITY_HEADER]: config.apiKey
+        };
+    } else {
+        producerConfig.AccessKeyID = config.ak || '';
+        producerConfig.AccessKeySecret = config.sk || '';
+    }
+    const producer = new tlsOpenapi.Producer(producerConfig);
+    producer.Start();
+    const entry = {
+        producer,
+        source: firstExternalIpv4(),
+        timeoutMs: config.timeoutMs ?? 20000
+    };
+    producerEntries.set(key, entry);
+    return entry;
+}
+async function sendTlsLogRecords(config, records, fileName) {
+    if (0 === records.length) return;
+    const entry = getProducer(config);
+    const logGroup = {
+        Logs: records.map((record)=>({
+                Time: Date.now(),
+                Contents: Object.entries(record).map(([Key, Value])=>({
+                        Key,
+                        Value
+                    }))
+            })),
+        Source: entry.source,
+        LogTags: [],
+        FileName: fileName
+    };
+    await withTimeout(new Promise((resolve, reject)=>{
+        let settled = false;
+        const settle = (fn, value)=>{
+            if (settled) return;
+            settled = true;
+            fn(value);
+        };
+        const resolveUnknown = resolve;
+        const sendPromise = entry.producer.SendLogs('', config.traceTopicId, entry.source, fileName, logGroup, {
+            Success: ()=>settle(resolveUnknown),
+            Fail: (result)=>{
+                const attempts = result?.Attempts ?? [];
+                const lastAttempt = attempts[attempts.length - 1] ?? {};
+                settle(reject, new Error(`TLS SendLogs failed topicId=${config.traceTopicId} requestId=${String(lastAttempt.RequestId ?? '')} errorCode=${String(lastAttempt.ErrorCode ?? '')} error=${JSON.stringify(lastAttempt)}`));
+            }
+        });
+        Promise.resolve(sendPromise).catch((error)=>settle(reject, error));
+    }), config.timeoutMs, 'TLS SendLogs');
+}
+async function closeTraceLogProducers() {
+    const entries = [
+        ...producerEntries.values()
+    ];
+    producerEntries.clear();
+    await Promise.allSettled(entries.map((entry)=>{
+        const closeTimeoutMs = Math.min(Math.max(entry.timeoutMs || 20000, 1000), 5000);
+        return withTimeout(Promise.resolve(entry.producer.Close()), closeTimeoutMs, 'TLS Producer Close');
+    }));
+}
+var package_namespaceObject = {
+    rE: "0.0.1"
+};
+function toOtlpAnyValue(value) {
+    if ('string' == typeof value) return {
+        stringValue: value
+    };
+    if ('boolean' == typeof value) return {
+        boolValue: value
+    };
+    if ('number' == typeof value) return Number.isInteger(value) ? {
+        intValue: String(value)
+    } : {
+        doubleValue: value
+    };
+    if (Array.isArray(value)) return {
+        arrayValue: {
+            values: value.map((item)=>toOtlpAnyValue(item))
+        }
+    };
+    if (value && 'object' == typeof value) return {
+        kvlistValue: {
+            values: Object.entries(value).filter(([, item])=>void 0 !== item).map(([key, item])=>({
+                    key,
+                    value: toOtlpAnyValue(item)
+                }))
+        }
+    };
+    return {
+        stringValue: String(value ?? '')
+    };
+}
+function toOtlpAttributes(attributes) {
+    return Object.entries(attributes).filter(([, value])=>null != value).map(([key, value])=>({
+            key,
+            value: toOtlpAnyValue(value)
+        }));
+}
+function otlpValueToJs(value) {
+    if (void 0 !== value.stringValue) return value.stringValue;
+    if (void 0 !== value.intValue) return Number(value.intValue);
+    if (void 0 !== value.doubleValue) return value.doubleValue;
+    if (void 0 !== value.boolValue) return value.boolValue;
+    if (value.arrayValue && 'object' == typeof value.arrayValue) {
+        const arr = value.arrayValue;
+        return (arr.values || []).map(otlpValueToJs);
+    }
+    if (value.kvlistValue && 'object' == typeof value.kvlistValue) {
+        const kv = value.kvlistValue;
+        const result = {};
+        for (const item of kv.values || [])result[item.key] = otlpValueToJs(item.value);
+        return result;
+    }
+    return value;
+}
+function otlpAttributesToMap(attributes) {
+    return attributes.reduce((acc, attr)=>{
+        acc[attr.key] = otlpValueToJs(attr.value);
+        return acc;
+    }, {});
+}
+function toUnixNanoString(ms) {
+    return String(BigInt(Math.trunc(Number.isFinite(ms) ? ms : Date.now())) * BigInt(1000000));
+}
+function spanKindToName(kind) {
+    const kindMap = {
+        0: 'unspecified',
+        1: 'internal',
+        2: 'server',
+        3: 'client',
+        4: 'producer',
+        5: 'consumer'
+    };
+    if ('number' == typeof kind) return kindMap[kind] || 'internal';
+    const upper = String(kind).toUpperCase();
+    if ('SERVER' === upper) return 'server';
+    if ('CLIENT' === upper) return 'client';
+    return 'internal';
+}
+function statusCodeToName(code) {
+    const statusMap = {
+        0: 'UNSET',
+        1: 'OK',
+        2: 'ERROR'
+    };
+    if (null == code) return 'UNSET';
+    const num = Number(code);
+    return statusMap[num] ?? 'UNSET';
+}
+function inferSpanTypeFromName(name, explicitType) {
+    if ('string' == typeof explicitType && explicitType) return explicitType;
+    if ('agent.turn' === name || 'codex_turn' === name) return 'message';
+    if ('llm.request' === name) return 'model';
+    if ('tool.call' === name) return 'tool';
+}
+function otlpSpanToTlsEnvelope(otlpSpan, resource, scope, options) {
+    const status = otlpSpan.status;
+    const statusCodeNum = Number(status?.code);
+    const isError = 2 === statusCodeNum;
+    const attributes = otlpAttributesToMap(otlpSpan.attributes || []);
+    const spanType = inferSpanTypeFromName(otlpSpan.name, otlpSpan.type);
+    const isTool = 'tool' === spanType;
+    if (isTool) attributes['tool.error'] = isError;
+    else delete attributes['tool.error'];
+    if (isError) {
+        attributes['error.type'] = attributes['error.type'] ?? 'error';
+        attributes['error.message'] = String(status?.message || '');
+    } else {
+        attributes['error.type'] = '';
+        attributes['error.message'] = '';
+    }
+    if (options?.filterAttributes) {
+        for (const key of Object.keys(attributes))if (!options.filterAttributes(key)) delete attributes[key];
+    }
+    const resourceAttributes = otlpAttributesToMap(resource.attributes || []);
+    const events = (otlpSpan.events || []).map((event)=>({
+            timeUnixNano: event.timeUnixNano,
+            name: event.name,
+            attributes: otlpAttributesToMap(event.attributes || [])
+        }));
+    const links = (otlpSpan.links || []).map((link)=>({
+            traceId: link.traceId,
+            spanId: link.spanId,
+            traceState: link.traceState,
+            attributes: otlpAttributesToMap(link.attributes || [])
+        }));
+    const startNano = BigInt(String(otlpSpan.startTimeUnixNano));
+    const endNano = BigInt(String(otlpSpan.endTimeUnixNano));
+    const us = BigInt(1000);
+    const durationUs = (endNano - startNano) / us;
+    return {
+        TraceID: String(otlpSpan.traceId),
+        SpanID: String(otlpSpan.spanId),
+        ParentSpanID: String(otlpSpan.parentSpanId || ''),
+        Name: String(otlpSpan.name),
+        Kind: spanKindToName(otlpSpan.kind),
+        Start: String(startNano / us),
+        End: String(endNano / us),
+        Duration: String(durationUs),
+        StatusCode: statusCodeToName(statusCodeNum),
+        StatusDescription: String(status?.message || ''),
+        Attributes: safeJsonStringify(attributes),
+        Resource: safeJsonStringify(resourceAttributes),
+        ServiceName: String(resourceAttributes['service.name'] || ''),
+        Host: String(resourceAttributes['host.name'] || ''),
+        OTLPName: String(scope.name),
+        OTLPVersion: String(scope.version),
+        Events: safeJsonStringify(events),
+        Links: safeJsonStringify(links),
+        TraceState: String(otlpSpan.traceState || '')
+    };
+}
+const TLS_AUTH_RESOURCE_KEYS = {
+    traceTopicId: 'tls.otel.tracetopic',
+    apiKey: 'tls.otel.apikey',
+    ak: 'tls.otel.ak',
+    sk: 'tls.otel.sk',
+    region: 'tls.otel.region'
+};
+const SCHEMA_FIELD_ORDER = [
+    'span.name',
+    'span.kind',
+    'tls.app.type',
+    'session.id',
+    'span.status.code',
+    'start_time_unix_us',
+    'end_time_unix_us',
+    'span.duration_us',
+    'service.name',
+    'service.instance.id',
+    'host.name',
+    'observed_time_unix_ms',
+    'telemetry.sdk.name',
+    'telemetry.sdk.language',
+    'telemetry.sdk.version',
+    'otel.scope.name',
+    'otel.scope.version',
+    'event.name',
+    'user.role',
+    'gen_ai.operation.name',
+    'gen_ai.provider.name',
+    'gen_ai.request.model',
+    'gen_ai.response.model',
+    'gen_ai.request.duration_ms',
+    'gen_ai.input.messages',
+    'gen_ai.output.messages',
+    'gen_ai.usage.input_tokens',
+    'gen_ai.usage.output_tokens',
+    'gen_ai.usage.reasoning.output_tokens',
+    'gen_ai.usage.cache_read.input_tokens',
+    'gen_ai.usage.cache_creation.input_tokens',
+    'gen_ai.usage.total_tokens',
+    'gen_ai.tool.name',
+    'gen_ai.tool.call.id',
+    'gen_ai.tool.call.arguments',
+    'gen_ai.tool.call.result',
+    'error.type',
+    'error.message'
+];
+function serializeForAttr(value) {
+    const serialized = 'string' == typeof value ? value : safeJsonStringify(value);
+    return String(serialized ?? '').slice(0, 65536);
+}
+function spanKind(span) {
+    if ('SERVER' === span.span_kind) return 2;
+    if ('CLIENT' === span.span_kind) return 3;
+    return 1;
+}
+function spanKindName(span) {
+    if ('SERVER' === span.span_kind) return 'server';
+    if ('CLIENT' === span.span_kind) return 'client';
+    return 'internal';
+}
+function unixMsToUs(ms) {
+    return String(1000 * Math.trunc(Number.isFinite(ms) ? ms : Date.now()));
+}
+function hasError(span) {
+    if (span.status?.code === 'ERROR') return true;
+    return Boolean(span.attributes['error.type']);
+}
+function buildResourceAttributes(trace, config) {
+    const attributes = {
+        ...trace.resource
+    };
+    if ('resource' === config.authMode) {
+        attributes[TLS_AUTH_RESOURCE_KEYS.traceTopicId] = config.traceTopicId;
+        attributes[TLS_AUTH_RESOURCE_KEYS.region] = config.region;
+        if (config.apiKey) attributes[TLS_AUTH_RESOURCE_KEYS.apiKey] = config.apiKey;
+        else {
+            attributes[TLS_AUTH_RESOURCE_KEYS.ak] = config.ak;
+            attributes[TLS_AUTH_RESOURCE_KEYS.sk] = config.sk;
+        }
+    }
+    return attributes;
+}
+function cleanSpanAttributesForOtlp(span) {
+    const attributes = {
+        ...span.attributes
+    };
+    for (const key of [
+        'span.name',
+        'span.kind',
+        'span.status.code',
+        'service.name',
+        'service.instance.id',
+        'host.name',
+        'telemetry.sdk.name',
+        'telemetry.sdk.language',
+        'telemetry.sdk.version'
+    ])delete attributes[key];
+    return attributes;
+}
+function buildOtlpPayload(trace, config) {
+    return {
+        resourceSpans: [
+            {
+                schemaUrl: trace.schema_url,
+                resource: {
+                    attributes: toOtlpAttributes(buildResourceAttributes(trace, config))
+                },
+                scopeSpans: [
+                    {
+                        schemaUrl: trace.schema_url,
+                        scope: {
+                            name: 'tls-observer-claude-code',
+                            version: package_namespaceObject.rE
+                        },
+                        spans: trace.spans.map((span)=>({
+                                traceId: span.trace_id,
+                                spanId: span.span_id,
+                                ...span.parent_span_id ? {
+                                    parentSpanId: span.parent_span_id
+                                } : {},
+                                name: span.name,
+                                kind: spanKind(span),
+                                startTimeUnixNano: toUnixNanoString(span.start_time_unix_ms),
+                                endTimeUnixNano: toUnixNanoString(span.end_time_unix_ms),
+                                attributes: toOtlpAttributes(cleanSpanAttributesForOtlp(span)),
+                                status: hasError(span) ? {
+                                    code: 2,
+                                    message: span.status?.message || 'error'
+                                } : {
+                                    code: span.status?.code === 'OK' ? 1 : 0
+                                }
+                            }))
+                    }
+                ]
+            }
+        ]
+    };
+}
+function requireExportConfig(config) {
+    if (!config.enabled) return {
+        ok: false,
+        reason: 'disabled'
+    };
+    const missing = [];
+    const endpoint = config.tlsEndpoint || config.otelEndpoint;
+    if (!endpoint) missing.push('CLAUDE_CODE_TLS_ENDPOINT or CLAUDE_CODE_TLS_OTEL_ENDPOINT');
+    if (!config.region) missing.push('CLAUDE_CODE_TLS_REGION');
+    if (!config.traceTopicId) missing.push('CLAUDE_CODE_TLS_TRACE_TOPIC_ID');
+    if (!config.apiKey && (!config.ak || !config.sk)) missing.push('CLAUDE_CODE_TLS_API_KEY or CLAUDE_CODE_TLS_AK/CLAUDE_CODE_TLS_SK');
+    if (config.apiKey && (config.ak || config.sk)) return {
+        ok: false,
+        reason: 'invalid_auth',
+        missing: [
+            'use apiKey or ak/sk, not both'
+        ]
+    };
+    if (missing.length > 0) return {
+        ok: false,
+        reason: 'missing_config',
+        missing
+    };
+    return {
+        ok: true,
+        url: endpoint
+    };
+}
+function exporter_producerConfig(config) {
+    return {
+        endpoint: config.tlsEndpoint || config.otelEndpoint || '',
+        region: config.region || '',
+        traceTopicId: config.traceTopicId || '',
+        apiKey: config.apiKey,
+        ak: config.ak,
+        sk: config.sk,
+        timeoutMs: config.exportTimeoutMs
+    };
+}
+async function exportTraceToTls(trace, config) {
+    const required = requireExportConfig(config);
+    if (!required.ok) return {
+        status: 'skipped',
+        reason: required.reason,
+        message: required.missing?.join(', '),
+        trace_id: trace.trace_id,
+        span_count: trace.spans.length
+    };
+    const otlpPayload = buildOtlpPayload(trace, config);
+    const resourceSpan = otlpPayload.resourceSpans[0];
+    const resource = resourceSpan.resource;
+    const scopeSpan = resourceSpan.scopeSpans[0];
+    const scope = scopeSpan.scope;
+    const otlpSpans = scopeSpan.spans;
+    const records = otlpSpans.map((otlpSpan)=>otlpSpanToTlsEnvelope(otlpSpan, resource, scope));
+    const totalPayloadBytes = records.reduce((sum, record)=>sum + Buffer.byteLength(JSON.stringify(record), 'utf8'), 0);
+    const startedAt = Date.now();
+    const diagnostics = {
+        endpoint_host: normalizeProducerEndpoint(required.url),
+        endpoint_path: 'SendLogs'
+    };
+    try {
+        await sendTlsLogRecords(exporter_producerConfig(config), records, 'claude-code-trace');
+    } catch (error) {
+        return {
+            status: 'failed',
+            reason: 'producer_error',
+            message: error instanceof Error ? error.message : String(error),
+            trace_id: trace.trace_id,
+            span_count: trace.spans.length,
+            payload_bytes: totalPayloadBytes,
+            attempts: 1,
+            duration_ms: Date.now() - startedAt,
+            ...diagnostics
+        };
+    }
+    return {
+        status: 'success',
+        trace_id: trace.trace_id,
+        span_count: trace.spans.length,
+        payload_bytes: totalPayloadBytes,
+        attempts: 1,
+        duration_ms: Date.now() - startedAt,
+        ...diagnostics
+    };
+}
+function stableFieldValue(value) {
+    if (null == value) return '';
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value) return value;
+    return serializeForAttr(value);
+}
+function inferUserRole(span) {
+    const input = span.input;
+    const role = input?.messages?.find((message)=>'string' == typeof message?.role)?.role;
+    return role || '';
+}
+function inferErrorMessage(span) {
+    if ('string' == typeof span.status?.message) return span.status.message;
+    const output = span.output;
+    if ('string' == typeof output?.error) return output.error;
+    return '';
+}
+function buildSchemaAlignedRecord(trace, span, observedTimeUnixMs = Date.now()) {
+    const attributes = span.attributes ?? {};
+    const resource = trace.resource ?? {};
+    const isModel = 'model' === span.type;
+    const isError = hasError(span);
+    const record = {
+        'span.name': span.name,
+        'span.kind': spanKindName(span),
+        'tls.app.type': attributes['tls.app.type'] ?? '',
+        'session.id': attributes['session.id'] ?? attributes['gen_ai.conversation.id'] ?? '',
+        'span.status.code': isError ? 'ERROR' : 'UNSET',
+        start_time_unix_us: unixMsToUs(span.start_time_unix_ms),
+        end_time_unix_us: unixMsToUs(span.end_time_unix_ms),
+        'span.duration_us': String(1000 * Math.max(0, Math.trunc(span.duration_ms))),
+        'service.name': resource['service.name'] ?? '',
+        'service.instance.id': resource['service.instance.id'] ?? '',
+        'host.name': resource['host.name'] ?? '',
+        observed_time_unix_ms: observedTimeUnixMs,
+        'telemetry.sdk.name': resource['telemetry.sdk.name'] ?? 'tls-observer-claude-code',
+        'telemetry.sdk.language': resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.version': resource['telemetry.sdk.version'] ?? '',
+        'otel.scope.name': 'tls-observer-claude-code',
+        'otel.scope.version': package_namespaceObject.rE,
+        'event.name': span.name,
+        'user.role': inferUserRole(span),
+        'gen_ai.operation.name': attributes['gen_ai.operation.name'] ?? '',
+        'gen_ai.provider.name': attributes['gen_ai.provider.name'] ?? '',
+        'gen_ai.request.model': attributes['gen_ai.request.model'] ?? '',
+        'gen_ai.response.model': attributes['gen_ai.response.model'] ?? '',
+        'gen_ai.request.duration_ms': isModel ? span.duration_ms : '',
+        'gen_ai.input.messages': attributes['gen_ai.input.messages'] ?? '',
+        'gen_ai.output.messages': attributes['gen_ai.output.messages'] ?? '',
+        'gen_ai.usage.input_tokens': attributes['gen_ai.usage.input_tokens'] ?? '',
+        'gen_ai.usage.output_tokens': attributes['gen_ai.usage.output_tokens'] ?? '',
+        'gen_ai.usage.reasoning.output_tokens': attributes['gen_ai.usage.reasoning.output_tokens'] ?? '',
+        'gen_ai.usage.cache_read.input_tokens': attributes['gen_ai.usage.cache_read.input_tokens'] ?? '',
+        'gen_ai.usage.cache_creation.input_tokens': attributes['gen_ai.usage.cache_creation.input_tokens'] ?? '',
+        'gen_ai.usage.total_tokens': attributes['gen_ai.usage.total_tokens'] ?? '',
+        'gen_ai.tool.name': attributes['gen_ai.tool.name'] ?? '',
+        'gen_ai.tool.call.id': attributes['gen_ai.tool.call.id'] ?? '',
+        'gen_ai.tool.call.arguments': attributes['gen_ai.tool.call.arguments'] ?? '',
+        'gen_ai.tool.call.result': attributes['gen_ai.tool.call.result'] ?? '',
+        'error.type': isError ? attributes['error.type'] ?? 'error' : '',
+        'error.message': isError ? attributes['error.message'] || inferErrorMessage(span) || '' : ''
+    };
+    return Object.fromEntries(SCHEMA_FIELD_ORDER.map((key)=>[
+            key,
+            stableFieldValue(record[key])
+        ]));
+}
+function buildSchemaAlignedRecords(trace, observedTimeUnixMs = Date.now()) {
+    return trace.spans.map((span)=>buildSchemaAlignedRecord(trace, span, observedTimeUnixMs));
+}
+function exportSummary(trace, result) {
+    return compactObject({
+        generated_at: new Date().toISOString(),
+        trace_id: trace.trace_id,
+        span_count: trace.spans.length,
+        export_status: result.status,
+        export_reason: result.reason,
+        export_message: result.message,
+        endpoint_host: result.endpoint_host,
+        endpoint_path: result.endpoint_path,
+        payload_bytes: result.payload_bytes,
+        duration_ms: result.duration_ms
+    });
+}
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_MS = 20;
+const SESSION_MAX_AGE_MS = 86400000;
+function sleep(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function lockPath(stateFilePath) {
+    return `${stateFilePath}.lock`;
+}
+async function acquireLock(stateFilePath) {
+    const lock = lockPath(stateFilePath);
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(stateFilePath), {
+        recursive: true
+    });
+    while(Date.now() < deadline)try {
+        const fd = __rspack_external_node_fs_5ea92f0c.openSync(lock, 'wx');
+        __rspack_external_node_fs_5ea92f0c.closeSync(fd);
+        return;
+    } catch  {
+        await sleep(LOCK_RETRY_MS);
+    }
+    try {
+        __rspack_external_node_fs_5ea92f0c.unlinkSync(lock);
+    } catch  {}
+    const fd = __rspack_external_node_fs_5ea92f0c.openSync(lock, 'wx');
+    __rspack_external_node_fs_5ea92f0c.closeSync(fd);
+}
+function releaseLock(stateFilePath) {
+    try {
+        __rspack_external_node_fs_5ea92f0c.unlinkSync(lockPath(stateFilePath));
+    } catch  {}
+}
+function loadState(stateFilePath) {
+    try {
+        return JSON.parse(__rspack_external_node_fs_5ea92f0c.readFileSync(stateFilePath, 'utf8'));
+    } catch  {
+        return {};
+    }
+}
+function getSessionState(state, sessionId) {
+    return state[sessionId] ?? {
+        last_line: -1,
+        last_offset: 0,
+        turn_count: 0,
+        updated: '',
+        tool_start_times: {},
+        tool_observations: {},
+        pending_subagent_traces: [],
+        subagent_turn_count: 0
+    };
+}
+async function atomicUpdateState(stateFilePath, fn) {
+    await acquireLock(stateFilePath);
+    try {
+        const next = pruneOldSessions(fn(loadState(stateFilePath)));
+        __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(stateFilePath), {
+            recursive: true
+        });
+        __rspack_external_node_fs_5ea92f0c.writeFileSync(stateFilePath, JSON.stringify(next, null, 2));
+    } finally{
+        releaseLock(stateFilePath);
+    }
+}
+function pruneOldSessions(state, now = Date.now()) {
+    const cutoff = now - SESSION_MAX_AGE_MS;
+    const pruned = {};
+    for (const [sessionId, session] of Object.entries(state)){
+        const updatedMs = session.updated ? new Date(session.updated).getTime() : 0;
+        if (updatedMs >= cutoff || session.current_turn_id) pruned[sessionId] = session;
+    }
+    return pruned;
+}
+function putToolObservation(session, observation) {
+    return {
+        ...session,
+        updated: new Date().toISOString(),
+        tool_observations: {
+            ...session.tool_observations,
+            [observation.tool_use_id]: {
+                ...session.tool_observations?.[observation.tool_use_id],
+                ...observation
+            }
+        }
+    };
+}
+const SCHEMA_URL = 'https://opentelemetry.io/schemas/1.41.0';
+const MAX_ATTRIBUTE_TEXT = 65536;
+const TLS_APP_TYPE = 'claude-code';
+const ROOT_SPAN_NAME = 'agent.turn';
+const LLM_SPAN_NAME = 'llm.request';
+const TOOL_SPAN_NAME = 'tool.call';
+function hashHex(value, length) {
+    const hex = createHash('sha256').update(value).digest('hex').slice(0, length);
+    if (!/^0+$/.test(hex)) return hex;
+    return '1'.padStart(length, '0');
+}
+function toTraceId(value) {
+    const compact = value.replace(/-/g, '').toLowerCase();
+    if (/^[0-9a-f]{32}$/.test(compact) && compact !== '0'.repeat(32)) return compact;
+    return hashHex(value, 32);
+}
+function toSpanId(...parts) {
+    return hashHex(parts.map((part)=>String(part ?? '')).join(':'), 16);
+}
+function parseMs(value, fallback) {
+    if ('number' == typeof value && Number.isFinite(value)) return Math.trunc(value);
+    const parsed = Date.parse(String(value ?? ''));
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function orderedTiming(startTime, endTime) {
+    const fallback = Date.now();
+    const startMs = parseMs(startTime, fallback);
+    const rawEndMs = parseMs(endTime, startMs);
+    if (rawEndMs < startMs) return {
+        startMs,
+        endMs: startMs
+    };
+    return {
+        startMs,
+        endMs: rawEndMs
+    };
+}
+function stringifyStructuredAttributes(attributes) {
+    return Object.fromEntries(Object.entries(attributes).map(([key, value])=>[
+            key,
+            null !== value && 'object' == typeof value ? clipString(safeJsonStringify(value)) : value
+        ]));
+}
+function traceSpan(options) {
+    const { startMs, endMs } = orderedTiming(options.startTime, options.endTime);
+    return {
+        trace_id: options.traceId,
+        span_id: options.spanId,
+        parent_span_id: options.parentSpanId ?? null,
+        name: options.name,
+        type: options.type,
+        span_kind: options.spanKind ?? ('entry' === options.type ? 'SERVER' : 'model' === options.type ? 'CLIENT' : 'INTERNAL'),
+        start_time: new Date(startMs).toISOString(),
+        end_time: new Date(endMs).toISOString(),
+        start_time_unix_ms: startMs,
+        end_time_unix_ms: endMs,
+        duration_ms: endMs - startMs,
+        attributes: compactObject(stringifyStructuredAttributes({
+            ...options.attributes ?? {},
+            'tls.app.type': TLS_APP_TYPE
+        })),
+        input: options.input,
+        output: options.output,
+        status: options.status
+    };
+}
+function clipString(value) {
+    return value.length > MAX_ATTRIBUTE_TEXT ? `${value.slice(0, MAX_ATTRIBUTE_TEXT)}...[truncated]` : value;
+}
+function normalizeValue(value, captureContent) {
+    if (!captureContent) return;
+    if ('string' == typeof value) return clipString(value);
+    if (null == value) return value;
+    const text = safeJsonStringify(value);
+    return text.length > MAX_ATTRIBUTE_TEXT ? `${text.slice(0, MAX_ATTRIBUTE_TEXT)}...[truncated]` : value;
+}
+function contentBlockToPart(block, captureContent) {
+    if ('text' === block.type) return {
+        type: 'text',
+        content: normalizeValue(block.text, captureContent) ?? ''
+    };
+    if ('thinking' === block.type) return {
+        type: 'reasoning',
+        content: normalizeValue(block.thinking, captureContent) ?? ''
+    };
+    return {
+        type: 'tool_call',
+        id: block.id,
+        name: block.name,
+        arguments: normalizeValue(block.input, captureContent)
+    };
+}
+function messageContentToParts(content, captureContent) {
+    if ('string' == typeof content) return [
+        {
+            type: 'text',
+            content: normalizeValue(content, captureContent) ?? ''
+        }
+    ];
+    return content.map((item)=>normalizeValue(item, captureContent));
+}
+function assistantOutputMessages(call, captureContent) {
+    return [
+        {
+            role: 'assistant',
+            parts: call.content.map((block)=>contentBlockToPart(block, captureContent))
+        }
+    ];
+}
+function messagesAttribute(messages, captureContent) {
+    if (!captureContent || !messages) return;
+    return clipString(safeJsonStringify(messages));
+}
+function toolResultMessage(toolCall, captureContent) {
+    return {
+        role: 'tool',
+        parts: [
+            {
+                type: 'tool_call_response',
+                id: toolCall.tool_use.id,
+                result: normalizeValue(toolCall.result?.content, captureContent)
+            }
+        ]
+    };
+}
+function usageAttributes(usage) {
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    return compactObject({
+        'gen_ai.usage.input_tokens': inputTokens || void 0,
+        'gen_ai.usage.output_tokens': outputTokens || void 0,
+        'gen_ai.usage.total_tokens': inputTokens || outputTokens ? inputTokens + outputTokens : void 0,
+        'gen_ai.usage.reasoning.output_tokens': usage.reasoning_output_tokens || void 0,
+        'gen_ai.usage.cache_read.input_tokens': cacheRead || void 0,
+        'gen_ai.usage.cache_creation.input_tokens': cacheCreation || void 0
+    });
+}
+function sumNumericAttribute(records, key) {
+    return records.reduce((sum, record)=>{
+        const value = record[key];
+        return 'number' == typeof value && Number.isFinite(value) ? sum + value : sum;
+    }, 0);
+}
+function rootUsageAttributes(calls) {
+    const usageRecords = calls.map((call)=>usageAttributes(call.usage));
+    const totalTokens = sumNumericAttribute(usageRecords, 'gen_ai.usage.total_tokens');
+    const inputTokens = sumNumericAttribute(usageRecords, 'gen_ai.usage.input_tokens');
+    const outputTokens = sumNumericAttribute(usageRecords, 'gen_ai.usage.output_tokens');
+    const reasoningOutputTokens = sumNumericAttribute(usageRecords, 'gen_ai.usage.reasoning.output_tokens');
+    const cacheReadInputTokens = sumNumericAttribute(usageRecords, 'gen_ai.usage.cache_read.input_tokens');
+    return compactObject({
+        'gen_ai.usage.total_tokens': totalTokens || void 0,
+        'gen_ai.usage.input_tokens': inputTokens || void 0,
+        'gen_ai.usage.output_tokens': outputTokens || void 0,
+        'gen_ai.usage.reasoning.output_tokens': reasoningOutputTokens || void 0,
+        'gen_ai.usage.cache_read.input_tokens': cacheReadInputTokens || void 0
+    });
+}
+function toolObservationForCall(toolCall, state) {
+    return state.tool_observations?.[toolCall.tool_use.id];
+}
+function toolTiming(toolCall, observation, fallbackStart, fallbackEnd) {
+    return {
+        start: observation?.start_time_ms ?? fallbackStart,
+        end: observation?.end_time_ms ?? toolCall.result?.timestamp ?? fallbackEnd
+    };
+}
+function commonSessionAttributes(input) {
+    return compactObject({
+        'session.id': input.session_id,
+        'gen_ai.conversation.id': input.session_id
+    });
+}
+function buildResource(config) {
+    return compactObject({
+        'service.name': config.serviceName,
+        'service.instance.id': config.serviceInstanceId,
+        'host.name': hostname(),
+        'telemetry.sdk.language': 'nodejs',
+        'telemetry.sdk.name': 'tls-observer-claude-code',
+        'telemetry.sdk.version': '0.1.0',
+        ...localIdentityMetadata()
+    });
+}
+function buildTraceFromTurn(options) {
+    const { input, turn, turnIndex, sessionState, config, extraAttributes } = options;
+    const traceSeed = [
+        input.session_id ?? 'claude',
+        turn.promptId ?? sessionState.current_turn_id ?? turnIndex,
+        turn.userTimestamp,
+        options.traceSeedSuffix
+    ].filter((part)=>void 0 !== part && '' !== part).join(':');
+    const traceId = toTraceId(traceSeed);
+    const spans = [];
+    const userStartMs = parseMs(turn.userTimestamp, Date.now());
+    const turnStartMs = Math.min(userStartMs, parseMs(sessionState.current_turn_start_ms, userStartMs), ...turn.llmCalls.map((call)=>parseMs(call.startTime, userStartMs)));
+    const activityEnds = [
+        ...turn.llmCalls.map((call)=>parseMs(call.endTime, turnStartMs)),
+        ...turn.llmCalls.flatMap((call)=>call.toolCalls.map((tool)=>parseMs(tool.result?.timestamp, turnStartMs)))
+    ].filter(Number.isFinite);
+    const turnEndMs = Math.max(turnStartMs, ...activityEnds, Date.now());
+    const turnSpanId = toSpanId(traceId, 'turn', turnIndex);
+    const sessionAttrs = compactObject({
+        ...commonSessionAttributes(input),
+        ...extraAttributes ?? {}
+    });
+    const userMessages = [
+        {
+            role: 'user',
+            parts: messageContentToParts(turn.userContent, config.captureContent)
+        }
+    ];
+    const lastAssistant = turn.llmCalls.at(-1);
+    const requestModel = lastAssistant?.model;
+    const responseModel = lastAssistant?.model;
+    const outputMessages = lastAssistant ? assistantOutputMessages(lastAssistant, config.captureContent) : void 0;
+    spans.push(traceSpan({
+        traceId,
+        spanId: turnSpanId,
+        name: ROOT_SPAN_NAME,
+        type: 'entry',
+        startTime: turnStartMs,
+        endTime: turnEndMs,
+        attributes: {
+            ...sessionAttrs,
+            'gen_ai.operation.name': 'invoke_agent',
+            'gen_ai.provider.name': 'anthropic',
+            'gen_ai.request.model': requestModel,
+            'gen_ai.response.model': responseModel,
+            'gen_ai.input.messages': messagesAttribute(userMessages, config.captureContent),
+            'gen_ai.output.messages': messagesAttribute(outputMessages, config.captureContent),
+            ...rootUsageAttributes(turn.llmCalls)
+        },
+        input: config.captureContent ? {
+            messages: userMessages
+        } : void 0,
+        output: config.captureContent && outputMessages ? {
+            messages: outputMessages
+        } : void 0,
+        status: turn.isComplete ? {
+            code: 'OK'
+        } : {
+            code: 'ERROR',
+            message: 'interrupted'
+        }
+    }));
+    const accumulatedMessages = [
+        ...userMessages
+    ];
+    for (const [llmIndex, call] of turn.llmCalls.entries()){
+        const output = assistantOutputMessages(call, config.captureContent);
+        const inputMessages = [
+            ...accumulatedMessages
+        ];
+        const llmSpanId = toSpanId(traceId, 'llm', llmIndex, call.startTime, call.endTime);
+        spans.push(traceSpan({
+            traceId,
+            spanId: llmSpanId,
+            parentSpanId: turnSpanId,
+            name: LLM_SPAN_NAME,
+            type: 'model',
+            spanKind: 'CLIENT',
+            startTime: call.startTime,
+            endTime: call.endTime,
+            attributes: {
+                ...sessionAttrs,
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.provider.name': 'anthropic',
+                'gen_ai.request.model': call.model,
+                'gen_ai.response.model': call.model,
+                'gen_ai.response.finish_reasons': call.stopReason ? [
+                    call.stopReason
+                ] : void 0,
+                'gen_ai.input.messages': messagesAttribute(inputMessages, config.captureContent),
+                'gen_ai.output.messages': messagesAttribute(output, config.captureContent),
+                ...usageAttributes(call.usage)
+            },
+            input: config.captureContent ? {
+                messages: inputMessages
+            } : void 0,
+            output: config.captureContent ? {
+                messages: output
+            } : void 0
+        }));
+        accumulatedMessages.push(...output);
+        for (const toolCall of call.toolCalls){
+            const observation = toolObservationForCall(toolCall, sessionState);
+            const timing = toolTiming(toolCall, observation, call.endTime, toolCall.result?.timestamp ?? call.endTime);
+            const isError = observation?.status === 'error' || toolCall.result?.is_error;
+            const toolOutput = observation?.tool_response ?? toolCall.result?.content;
+            const toolInput = observation?.tool_input ?? toolCall.tool_use.input;
+            const toolSpanId = toSpanId(traceId, 'tool', toolCall.tool_use.id);
+            spans.push(traceSpan({
+                traceId,
+                spanId: toolSpanId,
+                parentSpanId: turnSpanId,
+                name: TOOL_SPAN_NAME,
+                type: 'tool',
+                spanKind: 'INTERNAL',
+                startTime: timing.start,
+                endTime: timing.end,
+                attributes: {
+                    ...sessionAttrs,
+                    'gen_ai.operation.name': 'execute_tool',
+                    'gen_ai.tool.name': toolCall.tool_use.name,
+                    'gen_ai.tool.call.id': toolCall.tool_use.id,
+                    'gen_ai.tool.call.arguments': normalizeValue(toolInput, config.captureContent),
+                    'gen_ai.tool.call.result': normalizeValue(toolOutput, config.captureContent),
+                    'error.type': isError ? 'tool_error' : void 0,
+                    'error.message': isError ? normalizeValue(toolOutput, config.captureContent) : void 0
+                },
+                input: normalizeValue(toolInput, config.captureContent),
+                output: normalizeValue(toolOutput, config.captureContent),
+                status: isError ? {
+                    code: 'ERROR',
+                    message: 'tool_error'
+                } : {
+                    code: 'OK'
+                }
+            }));
+            accumulatedMessages.push(toolResultMessage(toolCall, config.captureContent));
+        }
+    }
+    return {
+        schema_url: SCHEMA_URL,
+        source: options.source ?? "claude_stop_hook_transcript",
+        trace_id: traceId,
+        resource: buildResource(config),
+        spans: spans.sort((left, right)=>left.start_time_unix_ms - right.start_time_unix_ms || left.end_time_unix_ms - right.end_time_unix_ms)
+    };
+}
+function buildCompactTrace(options) {
+    const { input, sessionState, config } = options;
+    const endMs = Date.now();
+    const startMs = sessionState.compaction_start_time_ms ?? endMs;
+    const traceId = toTraceId(`${input.session_id ?? 'claude'}:compact:${startMs}:${endMs}`);
+    const spanId = toSpanId(traceId, 'compact');
+    const trigger = input.trigger ?? sessionState.compaction_trigger;
+    const summary = normalizeValue(input.compact_summary, config.captureContent);
+    const customInstructions = normalizeValue(sessionState.compaction_custom_instructions, config.captureContent);
+    return {
+        schema_url: SCHEMA_URL,
+        source: 'claude_post_compact_hook',
+        trace_id: traceId,
+        resource: buildResource(config),
+        spans: [
+            traceSpan({
+                traceId,
+                spanId,
+                name: 'agent.compact',
+                type: 'event',
+                spanKind: 'INTERNAL',
+                startTime: startMs,
+                endTime: endMs,
+                attributes: {
+                    'session.id': input.session_id,
+                    'gen_ai.conversation.id': input.session_id,
+                    'gen_ai.operation.name': 'context_compaction',
+                    'event.name': 'context.compaction',
+                    'gen_ai.output.messages': messagesAttribute([
+                        {
+                            role: 'assistant',
+                            parts: [
+                                {
+                                    type: 'text',
+                                    content: summary ?? ''
+                                }
+                            ]
+                        }
+                    ], config.captureContent),
+                    'gen_ai.request.duration_ms': Math.max(0, endMs - startMs)
+                },
+                input: config.captureContent ? {
+                    trigger,
+                    custom_instructions: customInstructions
+                } : void 0,
+                output: config.captureContent ? {
+                    compact_summary: summary
+                } : void 0,
+                status: {
+                    code: 'OK'
+                }
+            })
+        ]
+    };
+}
+function buildStopFailureTrace(options) {
+    const { input, config } = options;
+    const now = Date.now();
+    const traceId = toTraceId(`${input.session_id ?? 'claude'}:stop-failure:${now}`);
+    const spanId = toSpanId(traceId, 'stop-failure');
+    const errorMessage = input.error || 'Claude Code turn failed';
+    return {
+        schema_url: SCHEMA_URL,
+        source: 'claude_stop_failure_hook',
+        trace_id: traceId,
+        resource: buildResource(config),
+        spans: [
+            traceSpan({
+                traceId,
+                spanId,
+                name: ROOT_SPAN_NAME,
+                type: 'event',
+                startTime: now,
+                endTime: now,
+                attributes: {
+                    'session.id': input.session_id,
+                    'gen_ai.operation.name': 'invoke_agent',
+                    'gen_ai.provider.name': 'anthropic',
+                    'gen_ai.conversation.id': input.session_id,
+                    'error.type': input.error_type || 'stop_failure',
+                    'error.message': errorMessage
+                },
+                output: {
+                    error: errorMessage
+                },
+                status: {
+                    code: 'ERROR',
+                    message: errorMessage
+                }
+            })
+        ]
+    };
+}
+async function writeTextFileAtomic(filePath, text, options = {}) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    const tempPath = __rspack_external_node_path_c5b9b54f.join(__rspack_external_node_path_c5b9b54f.dirname(filePath), `.${__rspack_external_node_path_c5b9b54f.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    let renamed = false;
+    try {
+        await __rspack_external_node_fs_promises_153e37e0.writeFile(tempPath, text, {
+            encoding: 'utf8',
+            ...void 0 === options.mode ? {} : {
+                mode: options.mode
+            }
+        });
+        await __rspack_external_node_fs_promises_153e37e0.rename(tempPath, filePath);
+        renamed = true;
+        if (void 0 !== options.mode) await __rspack_external_node_fs_promises_153e37e0.chmod(filePath, options.mode);
+    } finally{
+        if (!renamed) await __rspack_external_node_fs_promises_153e37e0.rm(tempPath, {
+            force: true
+        }).catch(()=>void 0);
+    }
+}
+async function writeJsonFileAtomic(filePath, value, options = {}) {
+    await writeTextFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
+}
+async function appendJsonlFile(filePath, values) {
+    const entries = Array.isArray(values) ? values : [
+        values
+    ];
+    if (0 === entries.length) return;
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, `${entries.map((entry)=>JSON.stringify(entry)).join('\n')}\n`, 'utf8');
+}
+async function trimJsonlFileByBytes(filePath, maxBytes) {
+    if (maxBytes <= 0) return void await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
+        force: true
+    }).catch(()=>void 0);
+    let stat;
+    try {
+        stat = await __rspack_external_node_fs_promises_153e37e0.stat(filePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    if (stat.size <= maxBytes) return;
+    const lines = (await __rspack_external_node_fs_promises_153e37e0.readFile(filePath, 'utf8')).split(/\r?\n/).filter(Boolean);
+    const kept = [];
+    let keptBytes = 0;
+    for(let index = lines.length - 1; index >= 0; index -= 1){
+        const line = lines[index];
+        const lineBytes = Buffer.byteLength(`${line}\n`, 'utf8');
+        if (kept.length > 0 && keptBytes + lineBytes > maxBytes) break;
+        kept.push(line);
+        keptBytes += lineBytes;
+        if (keptBytes >= maxBytes) break;
+    }
+    await writeTextFileAtomic(filePath, kept.length ? `${kept.reverse().join('\n')}\n` : '');
+}
+async function appendBoundedJsonlFile(filePath, values, maxBytes) {
+    await appendJsonlFile(filePath, values);
+    await trimJsonlFileByBytes(filePath, maxBytes);
+}
+function readTranscript(filePath, afterLine = -1, afterOffset = 0) {
+    let size;
+    try {
+        size = __rspack_external_node_fs_5ea92f0c.statSync(filePath).size;
+    } catch  {
+        return {
+            messages: [],
+            lastLine: afterLine,
+            lastOffset: Math.max(0, afterOffset)
+        };
+    }
+    const startOffset = Number.isFinite(afterOffset) && afterOffset > 0 && afterOffset <= size ? Math.trunc(afterOffset) : 0;
+    const usingOffset = startOffset > 0;
+    const fd = __rspack_external_node_fs_5ea92f0c.openSync(filePath, 'r');
+    try {
+        const chunkSize = 2097152;
+        const buf = Buffer.alloc(chunkSize);
+        const messages = [];
+        let lastLine = afterLine;
+        let lastOffset = startOffset;
+        let lineIndex = usingOffset ? afterLine : -1;
+        let partial = '';
+        let readPos = startOffset;
+        let cursorOffset = startOffset;
+        let bytesRead = 0;
+        while((bytesRead = __rspack_external_node_fs_5ea92f0c.readSync(fd, buf, 0, chunkSize, readPos)) > 0){
+            readPos += bytesRead;
+            const chunk = partial + buf.toString('utf8', 0, bytesRead);
+            const lines = chunk.split('\n');
+            partial = lines.pop() ?? '';
+            for (const line of lines){
+                const rawWithNewline = `${line}\n`;
+                cursorOffset += Buffer.byteLength(rawWithNewline, 'utf8');
+                const trimmed = line.trim();
+                if (trimmed) {
+                    lineIndex += 1;
+                    lastLine = lineIndex;
+                    lastOffset = cursorOffset;
+                    if (usingOffset || !(lineIndex <= afterLine)) try {
+                        messages.push(JSON.parse(trimmed));
+                    } catch  {}
+                }
+            }
+        }
+        if (partial.trim()) {
+            cursorOffset += Buffer.byteLength(partial, 'utf8');
+            lineIndex += 1;
+            lastLine = lineIndex;
+            lastOffset = cursorOffset;
+            if (usingOffset || lineIndex > afterLine) try {
+                messages.push(JSON.parse(partial.trim()));
+            } catch  {}
+        }
+        return {
+            messages,
+            lastLine,
+            lastOffset
+        };
+    } finally{
+        __rspack_external_node_fs_5ea92f0c.closeSync(fd);
+    }
+}
+function getTranscriptEndPosition(filePath) {
+    try {
+        return {
+            lastLine: -1,
+            lastOffset: __rspack_external_node_fs_5ea92f0c.statSync(filePath).size
+        };
+    } catch  {
+        return {
+            lastLine: -1,
+            lastOffset: 0
+        };
+    }
+}
+function isHumanMessage(msg) {
+    if ('user' !== msg.type) return false;
+    if ('string' == typeof msg.message.content) return true;
+    if (Array.isArray(msg.message.content)) return !msg.message.content.some((block)=>block?.type === 'tool_result');
+    return false;
+}
+function isToolResult(msg) {
+    return 'user' === msg.type && Array.isArray(msg.message.content) && msg.message.content.some((block)=>block?.type === 'tool_result');
+}
+function isAssistantMessage(msg) {
+    return 'assistant' === msg.type;
+}
+function stripModelDateSuffix(model) {
+    return model.replace(/-\d{8}$/, '');
+}
+function mergeAdjacentTextBlocks(blocks) {
+    const result = [];
+    let textBuffer = null;
+    for (const block of blocks){
+        if ('text' === block.type) {
+            textBuffer = (textBuffer ?? '') + block.text;
+            continue;
+        }
+        if (null !== textBuffer) {
+            result.push({
+                type: 'text',
+                text: textBuffer
+            });
+            textBuffer = null;
+        }
+        result.push(block);
+    }
+    if (null !== textBuffer) result.push({
+        type: 'text',
+        text: textBuffer
+    });
+    return result;
+}
+function mergeAssistantChunks(chunks) {
+    const first = chunks[0];
+    const last = chunks[chunks.length - 1];
+    const content = mergeAdjacentTextBlocks(chunks.flatMap((chunk)=>chunk.message.content ?? []));
+    return {
+        content,
+        model: stripModelDateSuffix(first.message.model || 'claude'),
+        usage: last.message.usage ?? {},
+        startTime: first.timestamp || new Date().toISOString(),
+        endTime: last.timestamp || first.timestamp || new Date().toISOString(),
+        stopReason: last.message.stop_reason
+    };
+}
+function toolResultContent(content) {
+    if ('string' == typeof content) return content;
+    return content.filter((item)=>item?.type === 'text' && 'string' == typeof item.text).map((item)=>item.text).join('');
+}
+function findToolResult(toolUseId, toolResults) {
+    for (const msg of toolResults)for (const block of msg.message.content)if ('tool_result' === block.type && block.tool_use_id === toolUseId) return {
+        content: toolResultContent(block.content),
+        timestamp: msg.timestamp || new Date().toISOString(),
+        agentId: msg.toolUseResult?.agentId,
+        is_error: block.is_error
+    };
+}
+function groupIntoTurns(messages) {
+    const turns = [];
+    let currentPromptId;
+    let currentUser = null;
+    let assistantChunks = new Map();
+    let assistantOrder = [];
+    let toolResults = [];
+    let hasStopReasonEndTurn = false;
+    function resetForUser(msg) {
+        currentUser = msg;
+        currentPromptId = msg.promptId;
+        assistantChunks = new Map();
+        assistantOrder = [];
+        toolResults = [];
+        hasStopReasonEndTurn = false;
+    }
+    function finalizeTurn(forceIncomplete = false) {
+        if (!currentUser || 0 === assistantChunks.size) return;
+        const assistantMessages = Array.from(assistantChunks.values()).flat();
+        const hasStopReasonField = assistantMessages.some((msg)=>void 0 !== msg.message.stop_reason);
+        const isComplete = hasStopReasonEndTurn || !forceIncomplete && !hasStopReasonField;
+        const llmCalls = [];
+        for (const messageId of assistantOrder){
+            const chunks = assistantChunks.get(messageId);
+            if (!chunks?.length) continue;
+            const merged = mergeAssistantChunks(chunks);
+            const toolUses = merged.content.filter((block)=>'tool_use' === block.type);
+            llmCalls.push({
+                content: merged.content,
+                model: merged.model,
+                usage: merged.usage,
+                startTime: merged.startTime,
+                endTime: merged.endTime,
+                stopReason: merged.stopReason,
+                toolCalls: toolUses.map((toolUse)=>{
+                    const result = findToolResult(toolUse.id, toolResults);
+                    return {
+                        tool_use: toolUse,
+                        result: result ? {
+                            content: result.content,
+                            timestamp: result.timestamp,
+                            is_error: result.is_error
+                        } : void 0,
+                        agentId: result?.agentId
+                    };
+                })
+            });
+        }
+        turns.push({
+            userContent: currentUser.message.content,
+            userTimestamp: currentUser.timestamp || new Date().toISOString(),
+            promptId: currentUser.promptId,
+            llmCalls,
+            isComplete
+        });
+    }
+    for (const msg of messages){
+        if (isHumanMessage(msg)) {
+            const isNewTurn = null === currentUser || void 0 !== msg.promptId && msg.promptId !== currentPromptId || void 0 === msg.promptId;
+            if (isNewTurn) {
+                finalizeTurn();
+                resetForUser(msg);
+            }
+            continue;
+        }
+        if (currentUser) {
+            if (isAssistantMessage(msg)) {
+                const messageId = msg.message.id || `${msg.timestamp || 'assistant'}:${assistantOrder.length}`;
+                if (!assistantChunks.has(messageId)) {
+                    assistantChunks.set(messageId, []);
+                    assistantOrder.push(messageId);
+                }
+                assistantChunks.get(messageId)?.push(msg);
+                if ('end_turn' === msg.message.stop_reason) hasStopReasonEndTurn = true;
+                continue;
+            }
+            if (isToolResult(msg)) toolResults.push(msg);
+        }
+    }
+    finalizeTurn(true);
+    return turns;
+}
+function expandHome(filePath) {
+    if (!filePath) return;
+    if ('~' === filePath) return homedir();
+    if (filePath.startsWith('~/')) return __rspack_external_node_path_c5b9b54f.join(homedir(), filePath.slice(2));
+    return filePath;
+}
+function sanitizeFileName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 160) || 'trace';
+}
+async function writeSendLog(config, record) {
+    await writeJsonFileAtomic(__rspack_external_node_path_c5b9b54f.join(config.sendLogsDir, 'latest.send-log.json'), record);
+    await appendBoundedJsonlFile(__rspack_external_node_path_c5b9b54f.join(config.dataRoot, 'logs', 'diagnostics', 'send-log.jsonl'), record, config.diagnosticLogMaxBytes);
+}
+async function writeDebugArtifacts(config, trace) {
+    if (!config.debugArtifacts) return {};
+    const baseName = sanitizeFileName(`${trace.trace_id}.${Date.now()}`);
+    const tracePath = __rspack_external_node_path_c5b9b54f.join(config.artifactsDir, 'otel-traces', `${baseName}.trace.json`);
+    const payloadPath = __rspack_external_node_path_c5b9b54f.join(config.artifactsDir, 'otlp-payloads', `${baseName}.otlp.json`);
+    const schemaPath = __rspack_external_node_path_c5b9b54f.join(config.artifactsDir, 'schema-aligned', `${baseName}.schema-aligned.json`);
+    await writeJsonFileAtomic(tracePath, {
+        generated_at: new Date().toISOString(),
+        trace
+    });
+    await writeJsonFileAtomic(payloadPath, buildOtlpPayload(trace, config));
+    await writeJsonFileAtomic(schemaPath, {
+        generated_at: new Date().toISOString(),
+        records: buildSchemaAlignedRecords(trace)
+    });
+    return {
+        trace_path: tracePath,
+        otlp_payload_path: payloadPath,
+        schema_aligned_path: schemaPath
+    };
+}
+async function exportTraceAndLog(options) {
+    const { config, trace, hookEventName } = options;
+    const artifacts = await writeDebugArtifacts(config, trace);
+    const result = await exportTraceToTls(trace, config);
+    await writeSendLog(config, {
+        ...exportSummary(trace, result),
+        hook_event_name: hookEventName,
+        capture_content: config.captureContent,
+        debug_artifacts: config.debugArtifacts,
+        ...artifacts
+    });
+}
+function synthesizeMissingFinalAssistant(turns, input, session) {
+    if (!turns.length || !input.last_assistant_message) return;
+    const lastTurn = turns[turns.length - 1];
+    const lastLlm = lastTurn.llmCalls.at(-1);
+    if (!lastLlm || 0 === lastLlm.toolCalls.length) return;
+    const lastToolEnd = Math.max(...lastLlm.toolCalls.map((tool)=>session.tool_observations?.[tool.tool_use.id]?.end_time_ms).filter((value)=>Number.isFinite(value)), Date.parse(lastLlm.endTime));
+    lastTurn.llmCalls.push({
+        content: [
+            {
+                type: 'text',
+                text: input.last_assistant_message
+            }
+        ],
+        model: lastLlm.model,
+        usage: {},
+        startTime: new Date(lastToolEnd).toISOString(),
+        endTime: new Date().toISOString(),
+        toolCalls: [],
+        synthetic: true
+    });
+}
+async function exportTranscriptTurns(options) {
+    const { messages, lastLine, lastOffset } = readTranscript(options.transcriptPath, options.afterLine, options.afterOffset ?? 0);
+    const turns = groupIntoTurns(messages);
+    if (options.synthesizeFinalAssistant) synthesizeMissingFinalAssistant(turns, options.input, options.session);
+    let tracedTurns = 0;
+    for (const turn of turns){
+        const trace = buildTraceFromTurn({
+            input: options.input,
+            turn,
+            turnIndex: (options.turnIndexBase ?? options.session.turn_count) + tracedTurns + 1,
+            sessionState: options.session,
+            config: options.config,
+            source: options.source,
+            traceSeedSuffix: options.traceSeedSuffix,
+            extraAttributes: options.extraAttributes
+        });
+        await exportTraceAndLog({
+            config: options.config,
+            trace,
+            hookEventName: options.hookEventName
+        });
+        tracedTurns += 1;
+    }
+    return {
+        lastLine,
+        lastOffset,
+        tracedTurns
+    };
+}
+async function exportPendingSubagents(options) {
+    const pending = options.session.pending_subagent_traces ?? [];
+    let tracedTurns = 0;
+    for (const [index, subagent] of pending.entries()){
+        const transcriptPath = expandHome(subagent.agent_transcript_path);
+        if (!transcriptPath) continue;
+        const input = {
+            hook_event_name: 'Stop',
+            session_id: options.input.session_id,
+            transcript_path: transcriptPath
+        };
+        const sessionState = {
+            ...options.session,
+            current_turn_id: `${options.session.current_turn_id ?? options.input.session_id ?? 'claude'}:subagent:${subagent.agent_id ?? index}`
+        };
+        const result = await exportTranscriptTurns({
+            input,
+            config: options.config,
+            transcriptPath,
+            afterLine: -1,
+            afterOffset: 0,
+            session: sessionState,
+            hookEventName: options.input.hook_event_name ?? 'SubagentStop',
+            source: "claude_subagent_stop_transcript",
+            traceSeedSuffix: `subagent:${subagent.agent_id ?? index}`,
+            turnIndexBase: options.session.subagent_turn_count ?? 0,
+            extraAttributes: {
+                'gen_ai.agent.id': subagent.agent_id,
+                'gen_ai.agent.name': subagent.agent_type
+            }
+        });
+        tracedTurns += result.tracedTurns;
+    }
+    return tracedTurns;
+}
+async function handlePreCompact(input, config) {
+    if (!input.session_id) return;
+    const sessionId = input.session_id;
+    const startMs = Date.now();
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: {
+                ...session,
+                compaction_start_time_ms: startMs,
+                compaction_trigger: input.trigger,
+                compaction_custom_instructions: input.custom_instructions,
+                updated: new Date().toISOString()
+            }
+        };
+    });
+}
+async function handlePostCompact(input, config) {
+    if (!input.session_id) return;
+    const sessionId = input.session_id;
+    const session = getSessionState(loadState(config.stateFilePath), sessionId);
+    const trace = buildCompactTrace({
+        input,
+        sessionState: session,
+        config
+    });
+    await exportTraceAndLog({
+        config,
+        trace,
+        hookEventName: 'PostCompact'
+    });
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const latestSession = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: {
+                ...latestSession,
+                compaction_start_time_ms: void 0,
+                compaction_trigger: void 0,
+                compaction_custom_instructions: void 0,
+                updated: new Date().toISOString()
+            }
+        };
+    });
+}
+const TRANSCRIPT_FLUSH_DELAY_MS = 200;
+function clearedActiveSession(session, updates = {}) {
+    return {
+        ...session,
+        ...updates,
+        current_turn_id: void 0,
+        current_turn_start_ms: void 0,
+        current_prompt: void 0,
+        tool_start_times: {},
+        tool_observations: {},
+        pending_subagent_traces: [],
+        updated: new Date().toISOString()
+    };
+}
+async function waitForTranscriptFlush() {
+    await new Promise((resolve)=>setTimeout(resolve, TRANSCRIPT_FLUSH_DELAY_MS));
+}
+async function handleStop(input, config) {
+    if (!input.session_id || input.stop_hook_active) return;
+    const sessionId = input.session_id;
+    const transcriptPath = expandHome(input.transcript_path);
+    if (!transcriptPath) return;
+    await waitForTranscriptFlush();
+    const session = getSessionState(loadState(config.stateFilePath), sessionId);
+    const mainResult = await exportTranscriptTurns({
+        input,
+        config,
+        transcriptPath,
+        afterLine: session.last_line,
+        afterOffset: session.last_offset ?? 0,
+        session,
+        hookEventName: 'Stop',
+        synthesizeFinalAssistant: true
+    });
+    const subagentTurns = await exportPendingSubagents({
+        input,
+        config,
+        session
+    });
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const latestSession = getSessionState(state, sessionId);
+        const updates = 0 === mainResult.tracedTurns && 0 === subagentTurns ? {} : {
+            last_line: mainResult.lastLine,
+            last_offset: mainResult.lastOffset,
+            turn_count: latestSession.turn_count + mainResult.tracedTurns,
+            subagent_turn_count: (latestSession.subagent_turn_count ?? 0) + subagentTurns
+        };
+        return {
+            ...state,
+            [sessionId]: clearedActiveSession(latestSession, updates)
+        };
+    });
+}
+async function handleStopFailure(input, config) {
+    const trace = buildStopFailureTrace({
+        input,
+        config
+    });
+    await exportTraceAndLog({
+        config,
+        trace,
+        hookEventName: 'StopFailure'
+    });
+}
+async function handleSessionEnd(input, config) {
+    if (!input.session_id) return;
+    const sessionId = input.session_id;
+    const transcriptPath = expandHome(input.transcript_path);
+    const session = getSessionState(loadState(config.stateFilePath), sessionId);
+    if (!session.current_turn_id && !session.pending_subagent_traces?.length) return;
+    await waitForTranscriptFlush();
+    let lastLine = session.last_line;
+    let lastOffset = session.last_offset ?? 0;
+    let tracedTurns = 0;
+    if (transcriptPath && session.current_turn_id) {
+        const stopInput = {
+            hook_event_name: 'Stop',
+            session_id: sessionId,
+            transcript_path: transcriptPath
+        };
+        const result = await exportTranscriptTurns({
+            input: stopInput,
+            config,
+            transcriptPath,
+            afterLine: session.last_line,
+            afterOffset: session.last_offset ?? 0,
+            session,
+            hookEventName: 'SessionEnd',
+            source: "claude_session_end_transcript",
+            traceSeedSuffix: `session-end:${input.reason ?? 'unknown'}`
+        });
+        lastLine = result.lastLine;
+        lastOffset = result.lastOffset;
+        tracedTurns = result.tracedTurns;
+    }
+    const subagentTurns = await exportPendingSubagents({
+        input,
+        config,
+        session
+    });
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const latestSession = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: clearedActiveSession(latestSession, {
+                last_line: lastLine,
+                last_offset: lastOffset,
+                turn_count: latestSession.turn_count + tracedTurns,
+                subagent_turn_count: (latestSession.subagent_turn_count ?? 0) + subagentTurns
+            })
+        };
+    });
+}
+async function handleSubagentStop(input, config) {
+    if (!input.session_id) return;
+    const sessionId = input.session_id;
+    const agentTranscriptPath = expandHome(input.agent_transcript_path);
+    if (!agentTranscriptPath) return;
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = getSessionState(state, sessionId);
+        const pending = session.pending_subagent_traces ?? [];
+        const nextSubagent = {
+            agent_id: input.agent_id,
+            agent_type: input.agent_type,
+            agent_transcript_path: agentTranscriptPath,
+            session_id: sessionId
+        };
+        const alreadyQueued = pending.some((item)=>item.agent_transcript_path === nextSubagent.agent_transcript_path && item.agent_id === nextSubagent.agent_id);
+        return {
+            ...state,
+            [sessionId]: {
+                ...session,
+                pending_subagent_traces: alreadyQueued ? pending : [
+                    ...pending,
+                    nextSubagent
+                ],
+                updated: new Date().toISOString()
+            }
+        };
+    });
+}
+async function handlePreToolUse(input, config) {
+    if (!input.session_id || !input.tool_use_id) return;
+    const sessionId = input.session_id;
+    const toolUseId = input.tool_use_id;
+    const startMs = Date.now();
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: {
+                ...session,
+                updated: new Date().toISOString(),
+                tool_start_times: {
+                    ...session.tool_start_times,
+                    [toolUseId]: startMs
+                },
+                tool_observations: {
+                    ...session.tool_observations,
+                    [toolUseId]: {
+                        ...session.tool_observations?.[toolUseId],
+                        tool_use_id: toolUseId,
+                        tool_name: input.tool_name,
+                        tool_input: input.tool_input,
+                        start_time_ms: startMs
+                    }
+                }
+            }
+        };
+    });
+}
+async function handlePostToolUse(input, config) {
+    if (!input.session_id || !input.tool_use_id) return;
+    const sessionId = input.session_id;
+    const toolUseId = input.tool_use_id;
+    const endMs = Date.now();
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: putToolObservation(session, {
+                tool_use_id: toolUseId,
+                tool_name: input.tool_name,
+                tool_input: input.tool_input,
+                tool_response: input.tool_response,
+                start_time_ms: session.tool_start_times?.[toolUseId] ?? endMs,
+                end_time_ms: endMs,
+                status: 'PostToolUseFailure' === input.hook_event_name ? 'error' : 'ok'
+            })
+        };
+    });
+}
+async function handleUserPromptSubmit(input, config) {
+    if (!input.session_id) return;
+    const sessionId = input.session_id;
+    const startMs = Date.now();
+    const transcriptPath = expandHome(input.transcript_path);
+    let interruptedLastLine;
+    let interruptedLastOffset;
+    let interruptedTurns = 0;
+    let interruptedSubagentTurns = 0;
+    if (transcriptPath) {
+        const session = getSessionState(loadState(config.stateFilePath), sessionId);
+        if (session.current_turn_id) {
+            const stopInput = {
+                hook_event_name: 'Stop',
+                session_id: sessionId,
+                transcript_path: transcriptPath
+            };
+            const result = await exportTranscriptTurns({
+                input: stopInput,
+                config,
+                transcriptPath,
+                afterLine: session.last_line,
+                afterOffset: session.last_offset ?? 0,
+                session,
+                hookEventName: 'UserPromptSubmit',
+                source: "claude_interrupted_turn_transcript",
+                traceSeedSuffix: 'interrupted-before-new-prompt'
+            });
+            interruptedLastLine = result.lastLine;
+            interruptedLastOffset = result.lastOffset;
+            interruptedTurns = result.tracedTurns;
+            interruptedSubagentTurns = await exportPendingSubagents({
+                input: stopInput,
+                config,
+                session
+            });
+        }
+    }
+    const endPosition = transcriptPath ? getTranscriptEndPosition(transcriptPath) : {
+        lastLine: -1,
+        lastOffset: 0
+    };
+    await atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: {
+                ...session,
+                last_line: interruptedLastLine ?? (session.last_line >= 0 ? session.last_line : endPosition.lastLine),
+                last_offset: interruptedLastOffset ?? (session.last_offset && session.last_offset > 0 ? session.last_offset : endPosition.lastOffset),
+                turn_count: session.turn_count + interruptedTurns,
+                subagent_turn_count: (session.subagent_turn_count ?? 0) + interruptedSubagentTurns,
+                current_turn_id: `${sessionId}:${startMs}`,
+                current_turn_start_ms: startMs,
+                current_prompt: input.prompt,
+                tool_start_times: {},
+                tool_observations: {},
+                pending_subagent_traces: [],
+                updated: new Date().toISOString()
+            }
+        };
+    });
+}
+async function dispatchHook(input, config) {
+    switch(input.hook_event_name){
+        case 'UserPromptSubmit':
+            await handleUserPromptSubmit(input, config);
+            return;
+        case 'PreToolUse':
+            await handlePreToolUse(input, config);
+            return;
+        case 'PostToolUse':
+        case 'PostToolUseFailure':
+            await handlePostToolUse(input, config);
+            return;
+        case 'SubagentStop':
+            await handleSubagentStop(input, config);
+            return;
+        case 'PreCompact':
+            await handlePreCompact(input, config);
+            return;
+        case 'PostCompact':
+            await handlePostCompact(input, config);
+            return;
+        case 'Stop':
+            await handleStop(input, config);
+            return;
+        case 'StopFailure':
+            await handleStopFailure(input, config);
+            return;
+        case 'SessionEnd':
+            await handleSessionEnd(input, config);
+            return;
+        default:
+            return;
+    }
+}
+async function readStdinJson() {
+    const text = await new Promise((resolve, reject)=>{
+        let input = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk)=>{
+            input += chunk;
+        });
+        process.stdin.on('end', ()=>resolve(input));
+        process.stdin.on('error', reject);
+    });
+    if (!text.trim()) return {};
+    return JSON.parse(text);
+}
+async function main() {
+    try {
+        const input = await readStdinJson();
+        const config = loadConfig();
+        await __rspack_external_node_fs_promises_153e37e0.mkdir(config.dataRoot, {
+            recursive: true
+        });
+        await dispatchHook(input, config);
+    } finally{
+        await closeTraceLogProducers();
+    }
+}
+main().catch(async (error)=>{
+    try {
+        const config = loadConfig();
+        await writeSendLog(config, {
+            generated_at: new Date().toISOString(),
+            export_status: 'failed',
+            reason: 'hook_error',
+            message: error instanceof Error ? error.stack || error.message : String(error)
+        });
+    } catch  {}
+    process.exit(0);
+});