@volcengine/tls-observer-cursor 0.0.4

package/dist/index.js

@@ -0,0 +1,2097 @@
+import { homedir, hostname, networkInterfaces, userInfo } from "node:os";
+import { tlsOpenapi } from "@volcengine/openapi";
+import { createHash as external_node_crypto_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(), '.cursor', 'plugins', 'data', 'tls-observer-cursor');
+}
+function defaultEnvFile() {
+    return __rspack_external_node_path_c5b9b54f.join(homedir(), '.cursor', 'tls-observer-cursor.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('CURSOR_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('CURSOR_TLS_DATA_ROOT') || defaultDataRoot();
+    const serviceName = firstEnv('CURSOR_OTEL_SERVICE_NAME') || "cursor-transcript-hook";
+    const exportRetries = Math.min(envPositiveInteger('CURSOR_TLS_EXPORT_TIMEOUT_RETRIES', 1), 3);
+    return {
+        enabled: !envDisabled('CURSOR_TLS_EXPORT'),
+        dataRoot,
+        stateFilePath: firstEnv('CURSOR_TLS_STATE_FILE') || __rspack_external_node_path_c5b9b54f.join(dataRoot, 'state', 'cursor-state.json'),
+        sendLogsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'logs', 'send'),
+        artifactsDir: __rspack_external_node_path_c5b9b54f.join(dataRoot, 'artifacts'),
+        diagnosticLogMaxBytes: envPositiveInteger('CURSOR_TLS_DIAGNOSTIC_LOG_MAX_BYTES', 5242880),
+        captureContent: !envDisabled('CURSOR_TLS_CAPTURE_CONTENT'),
+        debugArtifacts: envFlag('CURSOR_TLS_DEBUG_ARTIFACTS', false),
+        serviceName,
+        serviceInstanceId: `${serviceName}@${hostname()}:${process.pid}`,
+        tlsEndpoint: firstEnv('CURSOR_TLS_ENDPOINT', 'TRACE_TLS_ENDPOINT', 'TLS_ENDPOINT'),
+        otelEndpoint: firstEnv('CURSOR_TLS_OTEL_ENDPOINT', 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'),
+        region: firstEnv('CURSOR_TLS_REGION', 'TLS_REGION'),
+        traceTopicId: firstEnv('CURSOR_TLS_TRACE_TOPIC_ID', 'CURSOR_TLS_TOPIC_ID', 'TLS_TRACE_TOPIC_ID'),
+        apiKey: firstEnv('CURSOR_TLS_API_KEY', 'TLS_API_KEY'),
+        ak: firstEnv('CURSOR_TLS_AK', 'TLS_AK'),
+        sk: firstEnv('CURSOR_TLS_SK', 'TLS_SK'),
+        authMode: 'resource' === firstEnv('CURSOR_TLS_AUTH_MODE', 'TLS_AUTH_MODE') ? 'resource' : 'header',
+        exportTimeoutMs: envPositiveInteger('CURSOR_TLS_EXPORT_TIMEOUT_MS', 20000),
+        exportTimeoutRetries: exportRetries,
+        transcriptLookbehindBytes: envPositiveInteger('CURSOR_TLS_TRANSCRIPT_LOOKBEHIND_BYTES', 4194304)
+    };
+}
+function localIdentityMetadata() {
+    return {
+        'user.name': userInfo().username
+    };
+}
+function json_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.4"
+};
+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: json_safeJsonStringify(attributes),
+        Resource: json_safeJsonStringify(resourceAttributes),
+        ServiceName: String(resourceAttributes['service.name'] || ''),
+        Host: String(resourceAttributes['host.name'] || ''),
+        OTLPName: String(scope.name),
+        OTLPVersion: String(scope.version),
+        Events: json_safeJsonStringify(events),
+        Links: json_safeJsonStringify(links),
+        TraceState: String(otlpSpan.traceState || '')
+    };
+}
+const TLS_AUTH_RESOURCE_KEYS = {
+    traceTopicId: 'tls.otel.tracetopic',
+    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 : json_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;
+    }
+    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-cursor',
+                            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('CURSOR_TLS_ENDPOINT or CURSOR_TLS_OTEL_ENDPOINT');
+    if (!config.region) missing.push('CURSOR_TLS_REGION');
+    if (!config.traceTopicId) missing.push('CURSOR_TLS_TRACE_TOPIC_ID');
+    if (!config.apiKey && (!config.ak || !config.sk)) missing.push('CURSOR_TLS_API_KEY or CURSOR_TLS_AK/CURSOR_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, 'cursor-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-cursor',
+        'telemetry.sdk.language': resource['telemetry.sdk.language'] ?? 'nodejs',
+        'telemetry.sdk.version': resource['telemetry.sdk.version'] ?? '',
+        'otel.scope.name': 'tls-observer-cursor',
+        '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 state_lockPath(stateFilePath) {
+    return `${stateFilePath}.lock`;
+}
+async function acquireLock(stateFilePath) {
+    const lock = state_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(state_lockPath(stateFilePath));
+    } catch  {}
+}
+function state_loadState(stateFilePath) {
+    try {
+        return JSON.parse(__rspack_external_node_fs_5ea92f0c.readFileSync(stateFilePath, 'utf8'));
+    } catch  {
+        return {};
+    }
+}
+function state_getSessionState(state, sessionId) {
+    return state[sessionId] ?? {
+        last_line: -1,
+        last_offset: 0,
+        turn_count: 0,
+        updated: '',
+        tool_start_times: {},
+        tool_observations: {},
+        tool_observation_order: [],
+        pending_subagent_traces: [],
+        subagent_turn_count: 0
+    };
+}
+async function state_atomicUpdateState(stateFilePath, fn) {
+    await acquireLock(stateFilePath);
+    try {
+        const next = pruneOldSessions(fn(state_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;
+}
+const SCHEMA_URL = 'https://opentelemetry.io/schemas/1.41.0';
+const MAX_ATTRIBUTE_TEXT = 65536;
+const TLS_APP_TYPE = 'cursor';
+const ROOT_SPAN_NAME = 'agent.turn';
+const LLM_SPAN_NAME = 'llm.request';
+const TOOL_SPAN_NAME = 'tool.call';
+function hashHex(value, length) {
+    const hex = external_node_crypto_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 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 = json_safeJsonStringify(value);
+    return text.length > MAX_ATTRIBUTE_TEXT ? `${text.slice(0, MAX_ATTRIBUTE_TEXT)}...[truncated]` : value;
+}
+function stringifyStructuredAttributes(attributes) {
+    return Object.fromEntries(Object.entries(attributes).map(([key, value])=>[
+            key,
+            null !== value && 'object' == typeof value ? clipString(json_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 modelId(model) {
+    if ('string' == typeof model) return model;
+    return model?.id ?? model?.display_name;
+}
+function inputModelId(input) {
+    return modelId(input.model) ?? input.model_id;
+}
+function contentBlockToPart(block, captureContent) {
+    if ('text' === block.type) return {
+        type: 'text',
+        content: normalizeValue(block.text, captureContent) ?? ''
+    };
+    if ('thinking' === block.type || 'reasoning' === block.type) return {
+        type: 'reasoning',
+        content: normalizeValue(block.thinking ?? block.text, captureContent) ?? ''
+    };
+    if ('tool_use' === block.type) return {
+        type: 'tool_call',
+        id: block.id,
+        name: block.name,
+        arguments: normalizeValue(block.input, captureContent)
+    };
+    return {
+        type: 'unknown',
+        content: ''
+    };
+}
+function messageContentToParts(content, captureContent) {
+    if ('string' == typeof content) return [
+        {
+            type: 'text',
+            content: normalizeValue(content, captureContent) ?? ''
+        }
+    ];
+    return content.map((item)=>normalizeValue(item, captureContent));
+}
+function assistantMessage(call, captureContent) {
+    return {
+        role: 'assistant',
+        parts: call.content.map((block)=>contentBlockToPart(block, captureContent))
+    };
+}
+function finishReasonForCall(call) {
+    if (call.stopReason) return call.stopReason;
+    return call.toolCalls.length > 0 ? 'tool_calls' : void 0;
+}
+function assistantOutputMessages(call, captureContent) {
+    const message = assistantMessage(call, captureContent);
+    const finishReason = finishReasonForCall(call);
+    return [
+        finishReason ? {
+            ...message,
+            finish_reason: finishReason
+        } : message
+    ];
+}
+function messagesAttribute(messages, captureContent) {
+    if (!captureContent || !messages) return;
+    return clipString(json_safeJsonStringify(messages));
+}
+function toolResultMessage(toolCallId, result, captureContent) {
+    const normalizedResult = normalizeValue(result, captureContent);
+    return {
+        role: 'tool',
+        parts: [
+            {
+                type: 'tool_call_response',
+                id: toolCallId,
+                response: normalizedResult,
+                result: normalizedResult
+            }
+        ]
+    };
+}
+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 commonSessionAttributes(input) {
+    const conversationId = input.conversation_id ?? input.session_id;
+    return compactObject({
+        'session.id': input.session_id ?? input.conversation_id,
+        'gen_ai.conversation.id': conversationId,
+        'cursor.session.id': input.session_id,
+        'cursor.conversation.id': input.conversation_id,
+        'cursor.generation.id': input.generation_id,
+        'cursor.session.name': input.session_name,
+        'cursor.version': input.cursor_version ?? input.version,
+        'cursor.user.email': input.user_email,
+        'cursor.cwd': input.cwd ?? input.workspace?.current_dir,
+        'cursor.workspace.roots': input.workspace_roots,
+        'cursor.workspace.project_dir': input.workspace?.project_dir,
+        "cursor.transcript_path": input.transcript_path,
+        'cursor.model.id': inputModelId(input),
+        'cursor.model.params': input.model_params
+    });
+}
+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-cursor',
+        'telemetry.sdk.version': '0.1.0',
+        ...localIdentityMetadata()
+    });
+}
+function buildTraceFromTurn(options) {
+    const { input, turn, turnIndex, sessionState, config, extraAttributes } = options;
+    const traceSeed = [
+        input.session_id ?? 'cursor',
+        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 fallbackEndMs = parseMs(options.turnEndTimeMs, Date.now());
+    const userStartMs = parseMs(turn.userTimestamp, parseMs(sessionState.current_turn_start_ms, fallbackEndMs));
+    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, fallbackEndMs);
+    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 = modelId(input.model) ?? lastAssistant?.model;
+    const responseModel = lastAssistant?.model ?? requestModel;
+    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': 'cursor',
+            '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 llmPointMs = parseMs(call.endTime, parseMs(call.startTime, turnStartMs));
+        const assistant = assistantMessage(call, config.captureContent);
+        const output = assistantOutputMessages(call, config.captureContent);
+        const inputMessages = 0 === llmIndex ? [
+            ...accumulatedMessages
+        ] : void 0;
+        const llmSpanId = toSpanId(traceId, 'llm', llmIndex, call.startTime, call.endTime);
+        const finishReason = finishReasonForCall(call);
+        spans.push(traceSpan({
+            traceId,
+            spanId: llmSpanId,
+            parentSpanId: turnSpanId,
+            name: LLM_SPAN_NAME,
+            type: 'model',
+            spanKind: 'CLIENT',
+            startTime: llmPointMs,
+            endTime: llmPointMs,
+            attributes: {
+                ...sessionAttrs,
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.provider.name': 'cursor',
+                'gen_ai.request.model': modelId(input.model) ?? call.model,
+                'gen_ai.response.model': call.model,
+                'gen_ai.response.finish_reasons': finishReason ? [
+                    finishReason
+                ] : void 0,
+                'gen_ai.input.messages': messagesAttribute(inputMessages, config.captureContent),
+                'gen_ai.output.messages': messagesAttribute(output, config.captureContent),
+                ...usageAttributes(call.usage)
+            },
+            input: config.captureContent && inputMessages ? {
+                messages: inputMessages
+            } : void 0,
+            output: config.captureContent ? {
+                messages: output
+            } : void 0
+        }));
+        accumulatedMessages.push(assistant);
+        for (const toolCall of call.toolCalls){
+            const toolInput = toolCall.tool_use.input;
+            const toolOutput = toolCall.result?.content;
+            const isError = toolCall.result?.is_error;
+            const toolSpanId = toSpanId(traceId, 'tool', toolCall.tool_use.id);
+            const errorType = 'tool_error';
+            spans.push(traceSpan({
+                traceId,
+                spanId: toolSpanId,
+                parentSpanId: llmSpanId,
+                name: TOOL_SPAN_NAME,
+                type: 'tool',
+                spanKind: 'INTERNAL',
+                startTime: llmPointMs,
+                endTime: llmPointMs,
+                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 ? errorType : 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: errorType
+                } : {
+                    code: 'OK'
+                }
+            }));
+            if (void 0 !== toolOutput) accumulatedMessages.push(toolResultMessage(toolCall.tool_use.id, toolOutput, config.captureContent));
+        }
+    }
+    return {
+        schema_url: SCHEMA_URL,
+        source: options.source ?? "cursor_stop_hook_transcript",
+        trace_id: traceId,
+        resource: buildResource(config),
+        spans: spans.sort((left, right)=>{
+            const leftRoot = null === left.parent_span_id ? -1 : 0;
+            const rightRoot = null === right.parent_span_id ? -1 : 0;
+            return leftRoot - rightRoot || left.start_time_unix_ms - right.start_time_unix_ms || left.end_time_unix_ms - right.end_time_unix_ms;
+        })
+    };
+}
+function hookTextMessages(role, text, captureContent) {
+    if (!text) return;
+    return [
+        {
+            role,
+            parts: [
+                {
+                    type: 'text',
+                    content: normalizeValue(text, captureContent) ?? ''
+                }
+            ]
+        }
+    ];
+}
+function buildTraceFromHookState(options) {
+    const { input, sessionState, config, turnIndex, extraAttributes } = options;
+    const prompt = sessionState.current_prompt;
+    const responseText = input.last_assistant_message;
+    const stopMs = options.stopTimeMs ?? Date.now();
+    const activityStarts = [
+        sessionState.current_turn_start_ms
+    ].filter((value)=>'number' == typeof value && Number.isFinite(value));
+    if (!prompt && !responseText) return;
+    const turnStartMs = Math.min(...activityStarts, stopMs);
+    const turnEndMs = Math.max(turnStartMs, stopMs);
+    const traceSeed = [
+        input.session_id ?? input.conversation_id ?? 'cursor',
+        input.generation_id,
+        sessionState.current_turn_id ?? turnIndex,
+        sessionState.current_turn_start_ms ?? turnStartMs,
+        options.traceSeedSuffix
+    ].filter((part)=>void 0 !== part && '' !== part).join(':');
+    const traceId = toTraceId(traceSeed);
+    const turnSpanId = toSpanId(traceId, 'turn', turnIndex);
+    const llmSpanId = toSpanId(traceId, 'llm', 'hook', turnIndex);
+    const sessionAttrs = compactObject({
+        ...commonSessionAttributes(input),
+        ...extraAttributes ?? {}
+    });
+    const userMessages = hookTextMessages('user', prompt, config.captureContent);
+    const outputMessages = hookTextMessages('assistant', responseText, config.captureContent);
+    const requestModel = inputModelId(input);
+    const responseModel = requestModel;
+    const spans = [];
+    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': 'cursor',
+            '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)
+        },
+        input: config.captureContent && userMessages ? {
+            messages: userMessages
+        } : void 0,
+        output: config.captureContent && outputMessages ? {
+            messages: outputMessages
+        } : void 0,
+        status: 'error' === input.reason ? {
+            code: 'ERROR',
+            message: 'error'
+        } : {
+            code: 'OK'
+        }
+    }));
+    spans.push(traceSpan({
+        traceId,
+        spanId: llmSpanId,
+        parentSpanId: turnSpanId,
+        name: LLM_SPAN_NAME,
+        type: 'model',
+        spanKind: 'CLIENT',
+        startTime: turnEndMs,
+        endTime: turnEndMs,
+        attributes: {
+            ...sessionAttrs,
+            'gen_ai.operation.name': 'chat',
+            'gen_ai.provider.name': 'cursor',
+            '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)
+        },
+        input: config.captureContent && userMessages ? {
+            messages: userMessages
+        } : void 0,
+        output: config.captureContent && outputMessages ? {
+            messages: outputMessages
+        } : void 0,
+        status: {
+            code: 'OK'
+        }
+    }));
+    return {
+        schema_url: SCHEMA_URL,
+        source: options.source ?? 'cursor_stop_hook_events',
+        trace_id: traceId,
+        resource: buildResource(config),
+        spans: spans.sort((left, right)=>{
+            const leftRoot = null === left.parent_span_id ? -1 : 0;
+            const rightRoot = null === right.parent_span_id ? -1 : 0;
+            return leftRoot - rightRoot || left.start_time_unix_ms - right.start_time_unix_ms || left.end_time_unix_ms - right.end_time_unix_ms;
+        })
+    };
+}
+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);
+}
+const DEFAULT_MAX_FILES = 3;
+const LOCK_STALE_MS = 30000;
+const jsonl_LOCK_TIMEOUT_MS = 5000;
+const jsonl_LOCK_RETRY_MS = 25;
+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 delay(ms) {
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function withJsonlFileLock(filePath, action) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    const lockPath = `${filePath}.lock`;
+    const startedAt = Date.now();
+    while(true)try {
+        const handle = await __rspack_external_node_fs_promises_153e37e0.open(lockPath, 'wx');
+        try {
+            await handle.writeFile(`${process.pid}:${new Date().toISOString()}\n`, 'utf8');
+            return await action();
+        } finally{
+            await handle.close().catch(()=>void 0);
+            await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                force: true
+            }).catch(()=>void 0);
+        }
+    } catch (error) {
+        if ('EEXIST' !== error.code) throw error;
+        try {
+            const stat = await __rspack_external_node_fs_promises_153e37e0.stat(lockPath);
+            if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                    force: true
+                }).catch(()=>void 0);
+                continue;
+            }
+        } catch (statError) {
+            if ('ENOENT' === statError.code) continue;
+            throw statError;
+        }
+        if (Date.now() - startedAt > jsonl_LOCK_TIMEOUT_MS) throw new Error(`Timed out waiting for JSONL file lock: ${lockPath}`);
+        await delay(jsonl_LOCK_RETRY_MS);
+    }
+}
+function rotatedFileName(filePath, now = new Date()) {
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext);
+    const stamp = now.toISOString().replace(/[-:.TZ]/g, '').slice(0, 17);
+    return __rspack_external_node_path_c5b9b54f.join(dir, `${base}.${stamp}.${process.pid}.${randomUUID()}${ext || '.jsonl'}`);
+}
+function rotatedFilePattern(filePath) {
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedExt = (ext || '.jsonl').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${base}\\.\\d{17}\\.\\d+\\.[0-9a-f-]+${escapedExt}$`);
+}
+async function pruneRotatedJsonlFiles(filePath, maxFiles) {
+    const maxRotatedFiles = Math.max(0, maxFiles - 1);
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const pattern = rotatedFilePattern(filePath);
+    let entries;
+    try {
+        entries = await __rspack_external_node_fs_promises_153e37e0.readdir(dir);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    const rotated = entries.filter((entry)=>pattern.test(entry)).sort((left, right)=>right.localeCompare(left)).map((entry)=>__rspack_external_node_path_c5b9b54f.join(dir, entry));
+    await Promise.all(rotated.slice(maxRotatedFiles).map((target)=>__rspack_external_node_fs_promises_153e37e0.rm(target, {
+            force: true
+        })));
+}
+async function rotateActiveJsonlFile(filePath, maxFiles) {
+    await __rspack_external_node_fs_promises_153e37e0.rename(filePath, rotatedFileName(filePath)).catch(async (error)=>{
+        if ('ENOENT' !== error.code) throw error;
+    });
+    await pruneRotatedJsonlFiles(filePath, maxFiles);
+}
+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, options = {}) {
+    const entries = Array.isArray(values) ? values : [
+        values
+    ];
+    if (0 === entries.length) return;
+    if ('rotate' !== options.strategy) return void await withJsonlFileLock(filePath, async ()=>{
+        await appendJsonlFile(filePath, entries);
+        await trimJsonlFileByBytes(filePath, maxBytes);
+    });
+    await withJsonlFileLock(filePath, async ()=>{
+        const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+        if (maxBytes <= 0 || maxFiles <= 0) {
+            await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
+                force: true
+            }).catch(()=>void 0);
+            await pruneRotatedJsonlFiles(filePath, 0);
+            return;
+        }
+        let currentBytes = 0;
+        try {
+            currentBytes = (await __rspack_external_node_fs_promises_153e37e0.stat(filePath)).size;
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        for (const entry of entries){
+            const line = `${JSON.stringify(entry)}\n`;
+            const lineBytes = Buffer.byteLength(line, 'utf8');
+            if (currentBytes > 0 && currentBytes + lineBytes > maxBytes) {
+                await rotateActiveJsonlFile(filePath, maxFiles);
+                currentBytes = 0;
+            }
+            await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, line, 'utf8');
+            currentBytes += lineBytes;
+        }
+        await pruneRotatedJsonlFiles(filePath, maxFiles);
+    });
+}
+function readTranscript(filePath, afterLine = -1, afterOffset = 0, options = {}) {
+    let size;
+    try {
+        size = __rspack_external_node_fs_5ea92f0c.statSync(filePath).size;
+    } catch  {
+        return {
+            messages: [],
+            lastLine: afterLine,
+            lastOffset: Math.max(0, afterOffset)
+        };
+    }
+    const offsetBeyondFile = Number.isFinite(afterOffset) && afterOffset > size;
+    const effectiveAfterLine = offsetBeyondFile ? -1 : afterLine;
+    const requestedOffset = Number.isFinite(afterOffset) && afterOffset > 0 && afterOffset <= size ? Math.trunc(afterOffset) : 0;
+    const lookBehindBytes = Math.max(0, Math.trunc(options.lookBehindBytes ?? 0));
+    const startOffset = requestedOffset > 0 ? Math.max(0, requestedOffset - lookBehindBytes) : 0;
+    const usingOffset = requestedOffset > 0;
+    const fd = __rspack_external_node_fs_5ea92f0c.openSync(filePath, 'r');
+    try {
+        let discardFirstLine = false;
+        if (startOffset > 0) {
+            const previousByte = Buffer.alloc(1);
+            __rspack_external_node_fs_5ea92f0c.readSync(fd, previousByte, 0, 1, startOffset - 1);
+            discardFirstLine = 0x0a !== previousByte[0];
+        }
+        const chunkSize = 2097152;
+        const buf = Buffer.alloc(chunkSize);
+        const messages = [];
+        let lastLine = effectiveAfterLine;
+        let lastOffset = startOffset;
+        let lineIndex = usingOffset ? effectiveAfterLine : -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`;
+                const lineStartOffset = cursorOffset;
+                cursorOffset += Buffer.byteLength(rawWithNewline, 'utf8');
+                if (discardFirstLine) {
+                    discardFirstLine = false;
+                    continue;
+                }
+                const trimmed = line.trim();
+                if (trimmed) {
+                    lineIndex += 1;
+                    lastLine = lineIndex;
+                    lastOffset = cursorOffset;
+                    if (usingOffset || !(lineIndex <= effectiveAfterLine)) try {
+                        messages.push({
+                            ...JSON.parse(trimmed),
+                            __line: lineIndex,
+                            __startOffset: lineStartOffset,
+                            __endOffset: cursorOffset
+                        });
+                    } catch  {}
+                }
+            }
+        }
+        if (partial.trim()) {
+            const lineStartOffset = cursorOffset;
+            cursorOffset += Buffer.byteLength(partial, 'utf8');
+            if (discardFirstLine) {
+                discardFirstLine = false;
+                return {
+                    messages,
+                    lastLine,
+                    lastOffset: cursorOffset
+                };
+            }
+            lineIndex += 1;
+            lastLine = lineIndex;
+            lastOffset = cursorOffset;
+            if (usingOffset || lineIndex > effectiveAfterLine) try {
+                messages.push({
+                    ...JSON.parse(partial.trim()),
+                    __line: lineIndex,
+                    __startOffset: lineStartOffset,
+                    __endOffset: cursorOffset
+                });
+            } 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 hashId(value) {
+    return external_node_crypto_createHash('sha256').update(JSON.stringify(value ?? '')).digest('hex').slice(0, 12);
+}
+function syntheticTime(baseMs, entry, blockIndex = 0) {
+    return new Date(baseMs + 10 * Math.max(0, entry.__line ?? 0) + blockIndex).toISOString();
+}
+function asUsage(value) {
+    return value && 'object' == typeof value ? value : {};
+}
+function textFromUnknown(value) {
+    if ('string' == typeof value) return value;
+    if (Array.isArray(value)) return value.map((item)=>{
+        if ('string' == typeof item) return item;
+        if (item && 'object' == typeof item && 'string' == typeof item.text) return item.text;
+        return '';
+    }).join('');
+    if (null == value) return '';
+    return JSON.stringify(value);
+}
+function contentArray(entry) {
+    const content = entry.message?.content;
+    if (Array.isArray(content)) return content;
+    if ('string' == typeof content) return [
+        {
+            type: 'text',
+            text: content
+        }
+    ];
+    return [];
+}
+function normalizeToolUse(block, entry, blockIndex) {
+    const name = String(block.name ?? block.tool_name ?? block.tool_type ?? 'tool');
+    const input = block.input && 'object' == typeof block.input ? block.input : block.tool_input && 'object' == typeof block.tool_input ? block.tool_input : {};
+    const id = String(block.id ?? block.tool_use_id ?? block.tool_call_id ?? `cursor-tool-${entry.__line ?? 'unknown'}-${blockIndex}-${hashId({
+        name,
+        input
+    })}`);
+    return {
+        type: 'tool_use',
+        id,
+        name,
+        input
+    };
+}
+function normalizeContent(entry) {
+    const blocks = [];
+    const toolResults = [];
+    for (const [index, raw] of contentArray(entry).entries()){
+        if ('string' == typeof raw) {
+            blocks.push({
+                type: 'text',
+                text: raw
+            });
+            continue;
+        }
+        if (!raw || 'object' != typeof raw) continue;
+        const block = raw;
+        const type = String(block.type ?? '');
+        if ('text' === type && 'string' == typeof block.text) {
+            const previous = blocks.at(-1);
+            if (previous?.type === 'text') previous.text += block.text;
+            else blocks.push({
+                type: 'text',
+                text: block.text
+            });
+            continue;
+        }
+        if ('thinking' === type || 'reasoning' === type) {
+            blocks.push({
+                type,
+                thinking: 'string' == typeof block.thinking ? block.thinking : textFromUnknown(block.text)
+            });
+            continue;
+        }
+        if ('tool_use' === type) {
+            blocks.push(normalizeToolUse(block, entry, index));
+            continue;
+        }
+        if ('tool_result' === type) toolResults.push({
+            type: 'tool_result',
+            tool_use_id: 'string' == typeof block.tool_use_id ? block.tool_use_id : void 0,
+            content: block.content,
+            is_error: Boolean(block.is_error)
+        });
+    }
+    return {
+        blocks,
+        toolResults
+    };
+}
+function isUserEntry(entry) {
+    return 'user' === entry.role || entry.message?.role === 'user';
+}
+function isAssistantEntry(entry) {
+    return 'assistant' === entry.role || entry.message?.role === 'assistant';
+}
+function isTurnEnd(entry) {
+    return 'turn_ended' === entry.type;
+}
+function userContent(entry) {
+    const normalized = normalizeContent(entry);
+    if (!normalized.blocks.length) return '';
+    if (normalized.blocks.every((block)=>'text' === block.type)) return normalized.blocks.map((block)=>block.text).join('');
+    return normalized.blocks;
+}
+function findToolResult(toolUseId, toolResults) {
+    const matched = toolResults.find((item)=>item.result.tool_use_id === toolUseId);
+    if (!matched) return;
+    return {
+        content: textFromUnknown(matched.result.content),
+        timestamp: matched.timestamp,
+        is_error: matched.result.is_error
+    };
+}
+function groupIntoTurns(messages, options = {}) {
+    const turns = [];
+    const baseMs = options.fallbackStartMs ?? Date.now();
+    let currentUser = null;
+    let assistantEntries = [];
+    let toolResults = [];
+    let currentTurnEndOffset;
+    let complete = false;
+    function finalize(forceIncomplete = false) {
+        if (!currentUser) return;
+        const llmCalls = assistantEntries.map((entry)=>{
+            const normalized = normalizeContent(entry);
+            const content = normalized.blocks;
+            for (const result of normalized.toolResults)toolResults.push({
+                result,
+                timestamp: entry.timestamp ?? syntheticTime(baseMs, entry)
+            });
+            if (!content.length) return;
+            const startTime = entry.timestamp ?? syntheticTime(baseMs, entry);
+            const endTime = entry.timestamp ?? syntheticTime(baseMs, entry, content.length);
+            const toolCalls = content.filter((block)=>'tool_use' === block.type).map((toolUse)=>{
+                const result = findToolResult(toolUse.id, toolResults);
+                return result ? {
+                    tool_use: toolUse,
+                    result
+                } : {
+                    tool_use: toolUse
+                };
+            });
+            return {
+                content,
+                model: entry.message?.model ?? options.fallbackModel ?? 'cursor-agent',
+                usage: asUsage(entry.message?.usage),
+                startTime,
+                endTime,
+                toolCalls,
+                stopReason: entry.message?.stop_reason
+            };
+        }).filter((call)=>Boolean(call));
+        turns.push({
+            userContent: userContent(currentUser),
+            userTimestamp: currentUser.timestamp ?? syntheticTime(baseMs, currentUser),
+            promptId: currentUser.promptId,
+            llmCalls,
+            isComplete: complete && !forceIncomplete,
+            startOffset: currentUser.__startOffset,
+            endOffset: currentTurnEndOffset ?? assistantEntries.at(-1)?.__endOffset ?? currentUser.__endOffset
+        });
+    }
+    for (const entry of messages){
+        if (isUserEntry(entry)) {
+            finalize();
+            currentUser = entry;
+            assistantEntries = [];
+            toolResults = [];
+            currentTurnEndOffset = void 0;
+            complete = false;
+            continue;
+        }
+        if (currentUser) {
+            if (isAssistantEntry(entry)) {
+                assistantEntries.push(entry);
+                continue;
+            }
+            if (isTurnEnd(entry)) {
+                complete = 'error' !== entry.status;
+                currentTurnEndOffset = entry.__endOffset;
+                finalize();
+                currentUser = null;
+                assistantEntries = [];
+                toolResults = [];
+                currentTurnEndOffset = void 0;
+                complete = false;
+            }
+        }
+    }
+    finalize(true);
+    return turns;
+}
+function trace_flow_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 trace_flow_sessionIdForInput(input, transcriptPath) {
+    if (input.session_id) return input.session_id;
+    if (input.conversation_id) return input.conversation_id;
+    const resolvedTranscript = transcriptPath ?? trace_flow_expandHome(input.transcript_path ?? void 0);
+    if (!resolvedTranscript) return;
+    const parts = resolvedTranscript.split(__rspack_external_node_path_c5b9b54f.sep).filter(Boolean);
+    const transcriptFile = parts.at(-1)?.replace(/\.jsonl$/i, '');
+    const parent = parts.at(-2);
+    return transcriptFile || parent;
+}
+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 trace_flow_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, turnEndTimeMs) {
+    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 = 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(turnEndTimeMs).toISOString(),
+        toolCalls: [],
+        synthetic: true
+    });
+}
+async function exportTranscriptTurns(options) {
+    const turnEndTimeMs = options.turnEndTimeMs ?? Date.now();
+    const { messages, lastLine, lastOffset } = readTranscript(options.transcriptPath, options.afterLine, options.afterOffset ?? 0, {
+        lookBehindBytes: options.config.transcriptLookbehindBytes
+    });
+    const parsedTurns = groupIntoTurns(messages, {
+        fallbackStartMs: options.session.current_turn_start_ms,
+        fallbackModel: 'string' == typeof options.input.model ? options.input.model : options.input.model?.id ?? options.input.model?.display_name
+    });
+    const afterOffset = options.afterOffset ?? 0;
+    const turns = afterOffset > 0 ? parsedTurns.filter((turn)=>void 0 === turn.endOffset || turn.endOffset > afterOffset) : parsedTurns;
+    if (options.synthesizeFinalAssistant) synthesizeMissingFinalAssistant(turns, options.input, turnEndTimeMs);
+    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,
+            turnEndTimeMs,
+            source: options.source,
+            traceSeedSuffix: options.traceSeedSuffix,
+            extraAttributes: options.extraAttributes
+        });
+        await trace_flow_exportTraceAndLog({
+            config: options.config,
+            trace,
+            hookEventName: options.hookEventName
+        });
+        tracedTurns += 1;
+    }
+    return {
+        lastLine,
+        lastOffset,
+        tracedTurns
+    };
+}
+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: {},
+        tool_observation_order: [],
+        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.stop_hook_active) return;
+    const stopTimeMs = Date.now();
+    const transcriptPath = trace_flow_expandHome(input.transcript_path ?? void 0);
+    const sessionId = trace_flow_sessionIdForInput(input, transcriptPath);
+    if (!sessionId) return;
+    await waitForTranscriptFlush();
+    const session = state_getSessionState(state_loadState(config.stateFilePath), sessionId);
+    let tracedTurns = 0;
+    let lastLine = session.last_line;
+    let lastOffset = session.last_offset ?? 0;
+    const stopInput = {
+        ...input,
+        hook_event_name: 'stop',
+        session_id: input.session_id ?? sessionId,
+        conversation_id: input.conversation_id ?? sessionId,
+        transcript_path: transcriptPath
+    };
+    if (transcriptPath) {
+        const result = await exportTranscriptTurns({
+            input: stopInput,
+            config,
+            transcriptPath,
+            afterLine: session.last_line,
+            afterOffset: session.last_offset ?? 0,
+            session,
+            hookEventName: input.hook_event_name,
+            turnEndTimeMs: stopTimeMs,
+            source: "cursor_stop_hook_transcript"
+        });
+        tracedTurns = result.tracedTurns;
+        lastLine = result.lastLine;
+        lastOffset = result.lastOffset;
+    }
+    if (0 === tracedTurns) {
+        const hookTrace = buildTraceFromHookState({
+            input: stopInput,
+            sessionState: session,
+            config,
+            turnIndex: session.turn_count + 1,
+            stopTimeMs,
+            source: 'cursor_stop_hook_state'
+        });
+        if (hookTrace) {
+            await trace_flow_exportTraceAndLog({
+                config,
+                trace: hookTrace,
+                hookEventName: input.hook_event_name
+            });
+            tracedTurns = 1;
+        }
+    }
+    await state_atomicUpdateState(config.stateFilePath, (state)=>{
+        const latestSession = state_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
+            })
+        };
+    });
+}
+async function handleSessionEnd(input, config) {
+    const stopTimeMs = Date.now();
+    const transcriptPath = trace_flow_expandHome(input.transcript_path ?? void 0);
+    const sessionId = trace_flow_sessionIdForInput(input, transcriptPath);
+    if (!sessionId) return;
+    const session = state_getSessionState(state_loadState(config.stateFilePath), sessionId);
+    if (!session.current_turn_id) return;
+    await waitForTranscriptFlush();
+    let tracedTurns = 0;
+    let lastLine = session.last_line;
+    let lastOffset = session.last_offset ?? 0;
+    const stopInput = {
+        ...input,
+        hook_event_name: 'stop',
+        session_id: input.session_id ?? sessionId,
+        conversation_id: input.conversation_id ?? sessionId,
+        transcript_path: transcriptPath
+    };
+    if (session.current_turn_id && transcriptPath) {
+        const result = await exportTranscriptTurns({
+            input: stopInput,
+            config,
+            transcriptPath,
+            afterLine: session.last_line,
+            afterOffset: session.last_offset ?? 0,
+            session,
+            hookEventName: input.hook_event_name,
+            turnEndTimeMs: stopTimeMs,
+            source: "cursor_session_end_transcript",
+            traceSeedSuffix: `session-end:${input.reason ?? 'unknown'}`
+        });
+        tracedTurns = result.tracedTurns;
+        lastLine = result.lastLine;
+        lastOffset = result.lastOffset;
+    }
+    if (session.current_turn_id && 0 === tracedTurns) {
+        const hookTrace = buildTraceFromHookState({
+            input: stopInput,
+            sessionState: session,
+            config,
+            turnIndex: session.turn_count + 1,
+            stopTimeMs,
+            source: 'cursor_session_end_hook_state',
+            traceSeedSuffix: `session-end:${input.reason ?? 'unknown'}`
+        });
+        if (hookTrace) {
+            await trace_flow_exportTraceAndLog({
+                config,
+                trace: hookTrace,
+                hookEventName: input.hook_event_name
+            });
+            tracedTurns = 1;
+        }
+    }
+    await state_atomicUpdateState(config.stateFilePath, (state)=>{
+        const latestSession = state_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
+            })
+        };
+    });
+}
+function promptText(input) {
+    if ('string' == typeof input.prompt) return input.prompt;
+    if ('string' == typeof input.user_prompt) return input.user_prompt;
+    if ('string' == typeof input.query) return input.query;
+    if ('string' == typeof input.text) return input.text;
+}
+async function handleUserPromptSubmit(input, config) {
+    const transcriptPath = trace_flow_expandHome(input.transcript_path ?? void 0);
+    const sessionId = trace_flow_sessionIdForInput(input, transcriptPath);
+    if (!sessionId) return;
+    const startMs = Date.now();
+    let interruptedLastLine;
+    let interruptedLastOffset;
+    let interruptedTurns = 0;
+    const previousSession = state_getSessionState(state_loadState(config.stateFilePath), sessionId);
+    if (previousSession.current_turn_id) {
+        const stopInput = {
+            ...input,
+            hook_event_name: 'stop',
+            session_id: input.session_id ?? sessionId,
+            conversation_id: input.conversation_id ?? sessionId,
+            transcript_path: transcriptPath
+        };
+        if (transcriptPath) {
+            const result = await exportTranscriptTurns({
+                input: stopInput,
+                config,
+                transcriptPath,
+                afterLine: previousSession.last_line,
+                afterOffset: previousSession.last_offset ?? 0,
+                session: previousSession,
+                hookEventName: input.hook_event_name,
+                source: "cursor_interrupted_turn_transcript",
+                traceSeedSuffix: 'interrupted-before-new-prompt'
+            });
+            interruptedTurns = result.tracedTurns;
+            interruptedLastLine = result.lastLine;
+            interruptedLastOffset = result.lastOffset;
+        }
+    }
+    const endPosition = transcriptPath ? getTranscriptEndPosition(transcriptPath) : {
+        lastLine: -1,
+        lastOffset: 0
+    };
+    await state_atomicUpdateState(config.stateFilePath, (state)=>{
+        const session = state_getSessionState(state, sessionId);
+        return {
+            ...state,
+            [sessionId]: {
+                ...session,
+                last_line: interruptedLastLine ?? endPosition.lastLine,
+                last_offset: interruptedLastOffset ?? endPosition.lastOffset,
+                turn_count: session.turn_count + interruptedTurns,
+                subagent_turn_count: session.subagent_turn_count ?? 0,
+                current_turn_id: `${sessionId}:${startMs}`,
+                current_turn_start_ms: startMs,
+                current_prompt: promptText(input),
+                tool_start_times: {},
+                tool_observations: {},
+                tool_observation_order: [],
+                pending_subagent_traces: [],
+                updated: new Date().toISOString()
+            }
+        };
+    });
+}
+function eventName(input) {
+    return String(input.hook_event_name ?? input.event_name ?? '');
+}
+async function dispatchHook(input, config) {
+    switch(eventName(input)){
+        case 'beforeSubmitPrompt':
+        case 'UserPromptSubmit':
+            await handleUserPromptSubmit(input, config);
+            return;
+        case 'stop':
+        case 'Stop':
+            await handleStop(input, config);
+            return;
+        case 'sessionEnd':
+        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);
+});