@juspay/neurolink 12.14.5 → 12.14.7

package/dist/cli/commands/proxy.d.ts

@@ -11,7 +11,7 @@
  */
 import type { CommandModule } from "yargs";
 import type { Hono } from "hono";
-import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyHealthProbe, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../types/index.js";
+import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyHealthProbe, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxyRestartSupervisorState as ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../types/index.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 /**
  * Drop a supervisor `version` that is not a string.

package/dist/cli/commands/proxy.js

@@ -12,6 +12,7 @@ import { applyAllClients, restoreAllClients, } from "../proxy-clients/registry.j
 import { resolveProxyConfigPath } from "../../proxy/proxyConfig.js";
 import { redactUrlsInText, sanitizeForLog, } from "../../utils/logSanitize.js";
 import { withTimeout } from "../../utils/async/withTimeout.js";
+import { startProxyHttpTrace } from "../../proxy/proxyTracer.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
 import { configureProxyKeepAliveDispatcher } from "../../proxy/proxyDispatcher.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
@@ -24,6 +25,7 @@ import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
+import { startProxyRestartControl } from "../../proxy/restartControl.js";
 import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
@@ -836,13 +838,36 @@ function spawnProxyUpdater(host, port, parentPid, rollingSupervisor = false) {
         workerLog.close();
     }
 }
-async function runProxyTelemetryManager(command) {
+async function runProxyTelemetryManager(command, argv) {
     const { existsSync } = await import("fs");
     if (!existsSync(PROXY_TELEMETRY_SCRIPT_PATH)) {
         throw new Error("Proxy telemetry helper files were not found in this installation. Reinstall NeuroLink with observability assets included.");
     }
     await new Promise((resolve, reject) => {
-        const child = spawn("bash", [PROXY_TELEMETRY_SCRIPT_PATH, command], {
+        const queryCommand = command === "doctor" || command === "query";
+        const queryArgs = [];
+        if (queryCommand && argv) {
+            for (const [key, option] of [
+                ["since", "--since"],
+                ["until", "--until"],
+                ["kind", "--kind"],
+                ["format", "--format"],
+                ["maxRows", "--max-rows"],
+                ["proxyUrl", "--proxy-url"],
+            ]) {
+                if (argv[key] !== undefined) {
+                    queryArgs.push(option, String(argv[key]));
+                }
+            }
+        }
+        const child = spawn(queryCommand ? process.execPath : "bash", queryCommand
+            ? [
+                join(dirname(PROXY_TELEMETRY_SCRIPT_PATH), command === "doctor"
+                    ? "check-proxy-telemetry.mjs"
+                    : "query-proxy-history.mjs"),
+                ...queryArgs,
+            ]
+            : [PROXY_TELEMETRY_SCRIPT_PATH, command], {
             stdio: "inherit",
             env: process.env,
         });
@@ -1077,6 +1102,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             rejectForUpdate: readiness.drainingForUpdate,
         };
         requestMetadata.set(c.req.raw, metadata);
+        const httpTrace = startProxyHttpTrace(metadata, Object.fromEntries(c.req.raw.headers));
         const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
             metadata.terminalResult = entry;
         }, (entry) => {
@@ -1086,6 +1112,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
             ? () => undefined
             : beginProxyRequest();
         const finish = () => {
+            httpTrace.end(metadata.terminalResult?.responseStatus ?? c.res.status, metadata.terminalResult?.terminalOutcome ?? "unknown", metadata.terminalErrorType);
             stopObservingFinalLog();
             finishActivity();
             // Borrowed traffic holds a concurrency slot for the lifetime of the
@@ -1098,7 +1125,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         // them at acceptance instead of publishing misleading placeholder values;
         // subsequent events carry the parsed metadata under the same request ID.
         try {
-            await persistProxyLifecycleAcceptance({
+            await httpTrace.run(() => persistProxyLifecycleAcceptance({
                 requestId: metadata.requestId,
                 method: metadata.method,
                 path: metadata.path,
@@ -1106,8 +1133,8 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                 requestBytes,
                 elapsedMs: 0,
                 monotonicMs: startedMonotonicMs,
-            });
-            await next();
+            }));
+            await httpTrace.run(next);
             const responseStatus = c.res.status;
             logProxyLifecycleEvent({
                 event: "response_headers",
@@ -1168,12 +1195,12 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     let accountingTimedOut = false;
                     let accountingFailed = false;
                     try {
-                        accountingFailed = await notifyRouteTerminal({
+                        accountingFailed = await httpTrace.run(() => notifyRouteTerminal({
                             outcome,
                             error,
                             observedBodyBytes,
                             responseChunks,
-                        });
+                        }));
                     }
                     catch {
                         accountingTimedOut = true;
@@ -1230,6 +1257,7 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                         errorCode: final?.errorCode ?? metadata.terminalErrorCode,
                     });
                     stopObservingFinalLog();
+                    httpTrace.end(final?.responseStatus ?? responseStatus, terminalOutcome, final?.errorType ?? metadata.terminalErrorType);
                 },
             });
         }
@@ -1258,6 +1286,9 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                 errorType: error instanceof Error ? error.name : "unknown_error",
                 errorCode: getProxyRuntimeErrorCode(error),
             });
+            httpTrace.end(getProxyRuntimeErrorCode(error) === "PROXY_TELEMETRY_UNAVAILABLE"
+                ? 503
+                : 502, "handler_error", error instanceof Error ? error.name : "unknown_error");
             throw error;
         }
     };
@@ -1330,8 +1361,9 @@ export async function createProxyStartApp(params) {
                 accountKey: attempt?.accountKey,
                 provider: attempt?.provider,
                 transportScope: attempt?.transportScope,
-                traceId: attempt?.traceId,
-                spanId: attempt?.spanId,
+                traceId: attempt?.traceId ?? metadata.traceId,
+                spanId: attempt?.spanId ?? metadata.spanId,
+                traceFlags: attempt?.traceFlags ?? metadata.traceFlags,
                 responseStatus: status,
                 responseTimeMs: Date.now() - metadata.startedAt,
                 errorType,
@@ -1341,6 +1373,9 @@ export async function createProxyStartApp(params) {
             logBodyCapture({
                 timestamp: new Date().toISOString(),
                 requestId: metadata.requestId,
+                traceId: attempt?.traceId ?? metadata.traceId,
+                spanId: attempt?.spanId ?? metadata.spanId,
+                traceFlags: attempt?.traceFlags ?? metadata.traceFlags,
                 model: metadata.model,
                 stream: metadata.stream,
                 phase: "client_response",
@@ -1400,6 +1435,15 @@ export async function createProxyStartApp(params) {
             .json()
             .catch(() => ({ action: undefined }));
         if (payload.action === "drain") {
+            // A rolling worker must keep admitting until the supervisor has a ready
+            // replacement. The legacy global drain can otherwise strand the listener
+            // behind maintenance responses when its caller stalls or disappears.
+            if (isProxySocketWorkerProcess()) {
+                return c.json({
+                    error: "rolling_restart_required",
+                    message: "Use neurolink proxy restart; global update drain is disabled for rolling workers.",
+                }, 409);
+            }
             if (!markProxyDrainingForUpdate(readiness)) {
                 return c.json({ error: "proxy_not_ready" }, 409);
             }
@@ -2777,6 +2821,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         filePrefix: "proxy-supervisor",
     });
     let currentUpdaterPid;
+    let restartControl;
     const rollingServer = await startRollingProxyServer({
         onEvent: (event) => logProxyLifecycleEvent({
             event: "supervisor_event",
@@ -2807,6 +2852,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 version: PROXY_VERSION,
                 updaterPid: currentUpdaterPid,
                 rolling: snapshot,
+                restartControl: restartControl?.identity,
             });
         },
         log: (message) => logger.always(message),
@@ -2843,13 +2889,46 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     };
     process.on("SIGUSR2", activatePendingUpdate);
     const readinessHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    try {
+        restartControl = await startProxyRestartControl({
+            stateDir: join(homedir(), ".neurolink"),
+            server: rollingServer,
+            log: (message) => logger.warn(message),
+            isUpdatePending: () => !!rollingReplacement || !!loadUpdateState()?.pendingRestartVersion,
+            getInstalledVersion: async () => {
+                const { execFile } = await import("node:child_process");
+                const { promisify } = await import("node:util");
+                const { stdout } = await promisify(execFile)(TRAMPOLINE_PATH, ["--version"], { timeout: 5_000, maxBuffer: 65_536 });
+                return stdout.trim();
+            },
+            getStatus: async () => {
+                const probeHost = readinessHost === "::" ? "::1" : readinessHost;
+                const response = await fetch(`http://${probeHost.includes(":") ? `[${probeHost}]` : probeHost}:${rollingServer.address.port}/status`, {
+                    headers: { connection: "close" },
+                    signal: AbortSignal.timeout(3_000),
+                });
+                if (!response.ok) {
+                    throw new Error("Serving status is unavailable.");
+                }
+                return response.json();
+            },
+        });
+    }
+    catch (error) {
+        // A control-plane setup failure must not stop an otherwise serving proxy.
+        logger.warn(`[proxy-supervisor] safe restart control unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const updatePersistedUpdaterPid = (updaterPid) => {
         currentUpdaterPid = updaterPid;
         const state = loadProxySupervisorState();
         if (!state || state.pid !== process.pid) {
             return;
         }
-        saveProxySupervisorState({ ...state, updaterPid });
+        saveProxySupervisorState({
+            ...state,
+            updaterPid,
+            restartControl: restartControl?.identity,
+        });
     };
     const updaterSupervisor = startUpdaterWorkerSupervisor({
         spawnWorker: () => spawnProxyUpdater(readinessHost, rollingServer.address.port, process.pid, true),
@@ -2872,6 +2951,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         stopping = true;
         logger.always(`[proxy-supervisor] shutting down (${signal})`);
         process.off("SIGUSR2", activatePendingUpdate);
+        await restartControl?.close();
         updaterSupervisor.stop();
         await rollingServer.close();
         await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
@@ -3507,6 +3587,8 @@ export const proxyStatusCommand = {
 // PROXY TELEMETRY COMMAND
 // =============================================================================
 const PROXY_TELEMETRY_ACTIONS = [
+    "doctor",
+    "query",
     "setup",
     "start",
     "stop",
@@ -3516,12 +3598,37 @@ const PROXY_TELEMETRY_ACTIONS = [
 ];
 export const proxyTelemetryCommand = {
     command: "telemetry <action>",
-    describe: "Manage the local OpenObserve stack and dashboard for proxy observability",
+    describe: "Query and verify stored OTel telemetry or manage the local observability stack",
     builder: (yargs) => yargs
         .positional("action", {
         type: "string",
         choices: [...PROXY_TELEMETRY_ACTIONS],
-        describe: "Telemetry action: setup, start, stop, status, logs, or import-dashboard",
+        describe: "Telemetry action: doctor, query, setup, start, stop, status, logs, or import-dashboard",
+    })
+        .option("since", {
+        type: "string",
+        description: "Inclusive ISO timestamp for stored telemetry",
+    })
+        .option("until", {
+        type: "string",
+        description: "Exclusive ISO timestamp for stored telemetry",
+    })
+        .option("kind", {
+        type: "string",
+        description: "Metadata kind for query, such as request_final or telemetry_delivery",
+    })
+        .option("format", {
+        type: "string",
+        choices: ["json", "text"],
+        description: "Doctor report format; query always returns JSON",
+    })
+        .option("max-rows", {
+        type: "number",
+        description: "Explicit bounded history record limit",
+    })
+        .option("proxy-url", {
+        type: "string",
+        description: "Proxy endpoint used by the read-only doctor",
     })
         .option("quiet", {
         type: "boolean",
@@ -3529,19 +3636,21 @@ export const proxyTelemetryCommand = {
         default: false,
         description: "Suppress the local CLI spinner and delegate directly",
     })
+        .example("neurolink proxy telemetry doctor --format json", "Verify field coverage, stored captures, trace correlation, and delivery evidence")
+        .example("neurolink proxy telemetry query --since 2026-09-15T00:00:00Z --kind request_final", "Read stored OTLP metadata without scanning proxy log files")
         .example("neurolink proxy telemetry setup", "Start OpenObserve, start the OTEL collector, and import the dashboard")
         .example("neurolink proxy telemetry start", "Start the local proxy telemetry stack without re-importing the dashboard")
         .example("neurolink proxy telemetry stop", "Stop the local OpenObserve and OTEL collector containers"),
     handler: async (argv) => {
         const action = argv.action;
-        const spinner = argv.quiet
+        const spinner = argv.quiet || action === "doctor" || action === "query"
             ? null
             : ora(`Running proxy telemetry ${action}...`).start();
         try {
             if (spinner) {
                 spinner.stop();
             }
-            await runProxyTelemetryManager(action);
+            await runProxyTelemetryManager(action, argv);
             if (spinner) {
                 spinner.succeed(`proxy telemetry ${action} completed`);
             }

package/dist/cli/commands/proxyRestart.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from "yargs";
+import type { ProxyRestartArgs } from "../../types/index.js";
+export declare const proxyRestartCommand: CommandModule<object, ProxyRestartArgs>;

package/dist/cli/commands/proxyRestart.js

@@ -0,0 +1,88 @@
+import { readFile, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { resolveProxyPaths } from "../../proxy/proxyPaths.js";
+import { requestProxyRestart } from "../../proxy/restartControl.js";
+const supervisorSchema = z.object({
+    pid: z.number().int().positive(),
+    restartControl: z.object({
+        protocol: z.literal(1),
+        socketPath: z.string(),
+        instanceId: z.string().uuid(),
+    }),
+});
+export const proxyRestartCommand = {
+    command: "restart",
+    describe: "Replace the serving worker without stopping the proxy listener",
+    builder: (yargs) => yargs
+        .option("check", {
+        type: "boolean",
+        default: false,
+        description: "Check restart readiness without changing the running proxy",
+    })
+        .option("dev", {
+        type: "boolean",
+        default: false,
+        description: "Use the isolated proxy state in .neurolink-dev/",
+    })
+        .option("format", {
+        type: "string",
+        choices: ["text", "json"],
+        default: "text",
+    })
+        .example("neurolink proxy restart --check", "Verify the running supervisor supports safe worker replacement")
+        .example("neurolink proxy restart", "Start a replacement, verify it, then let existing streams finish"),
+    handler: async (argv) => {
+        try {
+            const { stateDir } = resolveProxyPaths(argv.dev);
+            const saved = supervisorSchema.safeParse(JSON.parse(await readFile(join(stateDir, "proxy-supervisor-state.json"), "utf8")));
+            if (!saved.success) {
+                throw new Error("This running supervisor does not advertise safe restart support. It must first be upgraded through a separately planned service activation.");
+            }
+            const { pid, restartControl } = saved.data;
+            if (restartControl.socketPath !==
+                join(stateDir, `restart-${pid}-${restartControl.instanceId}.sock`)) {
+                throw new Error("Restart control path does not match the recorded supervisor.");
+            }
+            const socket = await lstat(restartControl.socketPath);
+            if (!socket.isSocket() ||
+                (socket.mode & 0o077) !== 0 ||
+                (process.getuid && socket.uid !== process.getuid())) {
+                throw new Error("Restart control socket ownership or permissions are invalid.");
+            }
+            const result = await requestProxyRestart(restartControl, argv.check);
+            if (result.supervisorPid !== pid) {
+                throw new Error("Restart control identity changed; outcome is unverified.");
+            }
+            if (argv.format === "json") {
+                console.info(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.info(result.message);
+                console.info(`Supervisor ${result.supervisorPid}; worker ${result.workerPid ?? "unknown"}; version ${result.version ?? "unknown"}; previous workers finishing requests: ${result.drainingWorkers}.`);
+                console.info("This operation preserves the supervisor and launchd settings. It does not reinstall the service.");
+            }
+            if (!result.ok) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : "Restart control is unavailable.";
+            if (argv.format === "json") {
+                const result = {
+                    ok: false,
+                    phase: "unverified",
+                    message,
+                };
+                console.info(JSON.stringify(result));
+            }
+            else {
+                console.error(message);
+            }
+            process.exitCode = 1;
+        }
+    },
+};
+//# sourceMappingURL=proxyRestart.js.map

package/dist/cli/parser.js

@@ -23,6 +23,7 @@ import { ObservabilityCommandFactory } from "./commands/observability.js";
 import { TelemetryCommandFactory } from "./commands/telemetry.js";
 import { proxyStartCommand, proxyStatusCommand, proxyTelemetryCommand, proxySetupCommand, proxyGuardCommand, proxyInstallCommand, proxyUninstallCommand, } from "./commands/proxy.js";
 import { proxyAnalyzeCommand } from "./commands/proxyAnalyze.js";
+import { proxyRestartCommand } from "./commands/proxyRestart.js";
 import { proxyShareCommand } from "./commands/proxyShare.js";
 import { proxyPeerCommand } from "./commands/proxyPeer.js";
 import { proxyExposeCommand } from "./commands/proxyExpose.js";
@@ -218,6 +219,7 @@ export function initializeCliParser() {
         builder: (yargs) => yargs
             .command(proxyStartCommand)
             .command(proxyStatusCommand)
+            .command(proxyRestartCommand)
             .command(proxyShareCommand)
             .command(proxyPeerCommand)
             .command(proxyExposeCommand)
@@ -228,7 +230,7 @@ export function initializeCliParser() {
             .command(proxyGuardCommand)
             .command(proxyInstallCommand)
             .command(proxyUninstallCommand)
-            .demandCommand(1, "Please specify a proxy subcommand: start, status, share <create|provision|url|list|status|pause|resume|revoke|topup|set|link|rotate|level|note|notes|receipts|delete>, peer <add|request|sync|receipts|net|redeem|list|status|test|remove|pause|resume|set>, expose, analyze, replay <export|compare>, telemetry <setup|start|stop|status|logs|import-dashboard>, setup, guard, install, or uninstall"),
+            .demandCommand(1, "Please specify a proxy subcommand: start, status, restart, share <create|provision|url|list|status|pause|resume|revoke|topup|set|link|rotate|level|note|notes|receipts|delete>, peer <add|request|sync|receipts|net|redeem|list|status|test|remove|pause|resume|set>, expose, analyze, replay <export|compare>, telemetry <setup|start|stop|status|logs|import-dashboard>, setup, guard, install, or uninstall"),
         handler: () => { },
     })
         // Evaluate Command Group - Using EvaluateCommandFactory

package/dist/proxy/bodyCaptureWorker.js

@@ -18,6 +18,8 @@ const snapshot = {
     pendingBytes: 0,
     maxPending: MAX_PENDING,
     maxPendingBytes: MAX_PENDING_BYTES,
+    highWaterPending: 0,
+    highWaterBytes: 0,
     rejectionReasons: {},
 };
 const pending = new Map();
@@ -161,9 +163,27 @@ export async function captureProxyBody(entry, logDir, consume) {
                 ? "body_worker_backoff"
                 : "body_capture_queue_full";
         snapshot.lastError = error;
+        snapshot.lastRejectedAt = new Date().toISOString();
         snapshot.rejectionReasons[error] =
             (snapshot.rejectionReasons[error] ?? 0) + 1;
-        return consume({ error, stored: { bodyWriteFailed: true } });
+        return consume({
+            error,
+            stored: { bodyWriteFailed: true },
+            admission: {
+                limitingResource: bytes > MAX_ENTRY_BYTES
+                    ? "entry"
+                    : Date.now() < retryAfter
+                        ? "worker"
+                        : snapshot.pending >= MAX_PENDING
+                            ? "captures"
+                            : "bytes",
+                estimatedBytes: Number.isFinite(bytes) ? bytes : undefined,
+                pending: snapshot.pending,
+                pendingBytes: snapshot.pendingBytes,
+                maxPending: MAX_PENDING,
+                maxPendingBytes: MAX_PENDING_BYTES,
+            },
+        });
     }
     let current;
     try {
@@ -207,7 +227,9 @@ export async function captureProxyBody(entry, logDir, consume) {
             },
         });
         snapshot.pending += 1;
+        snapshot.highWaterPending = Math.max(snapshot.highWaterPending, snapshot.pending);
         snapshot.pendingBytes += bytes;
+        snapshot.highWaterBytes = Math.max(snapshot.highWaterBytes, snapshot.pendingBytes);
         current.ref();
         try {
             current.postMessage({ id, entry, logDir, queuedAt: Date.now() });
@@ -248,6 +270,9 @@ export const __bodyCaptureWorkerTestHooks = {
             pending: 0,
             pendingBytes: 0,
             lastError: undefined,
+            lastRejectedAt: undefined,
+            highWaterPending: 0,
+            highWaterBytes: 0,
             rejectionReasons: {},
         });
     },

package/dist/proxy/codexUsage.js

@@ -45,6 +45,34 @@ import { sanitizeForLog } from "../utils/logSanitize.js";
 const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
     ? Math.floor(value)
     : 0;
+function usefulOutputItem(item) {
+    if (!item || typeof item !== "object") {
+        return false;
+    }
+    if ("type" in item) {
+        if (item.type === "function_call") {
+            return ("arguments" in item &&
+                typeof item.arguments === "string" &&
+                item.arguments.length > 0);
+        }
+        if (item.type === "custom_tool_call") {
+            return ("input" in item &&
+                typeof item.input === "string" &&
+                item.input.length > 0);
+        }
+        if (item.type === "output_text") {
+            return ("text" in item && typeof item.text === "string" && item.text.length > 0);
+        }
+        if (item.type === "refusal") {
+            return ("refusal" in item &&
+                typeof item.refusal === "string" &&
+                item.refusal.length > 0);
+        }
+    }
+    return ("content" in item &&
+        Array.isArray(item.content) &&
+        item.content.some(usefulOutputItem));
+}
 /**
  * Pull usage out of one parsed SSE `data:` payload.
  *
@@ -125,7 +153,7 @@ const CAPTURE_LIMIT_BYTES = 256 * 1024;
  */
 function createCaptureSink() {
     const target = process.env.NEUROLINK_PROXY_CODEX_CAPTURE;
-    if (!target) {
+    if (!target || process.env.NEUROLINK_PROXY_LOG_SINK === "otel") {
         return null;
     }
     let written = 0;
@@ -167,9 +195,13 @@ export function createCodexUsageTap() {
     let totalBytes = 0;
     const inspectEvidence = (events) => {
         for (const frame of events) {
+            if (frame.data.trim() === "[DONE]") {
+                continue;
+            }
             try {
                 const event = JSON.parse(frame.data);
                 if (!event || typeof event !== "object") {
+                    evidence.observationIncomplete = true;
                     continue;
                 }
                 const seen = extractCodexUsage(event);
@@ -178,10 +210,53 @@ export function createCodexUsageTap() {
                 }
                 const type = event.type ?? frame.event;
                 if ((type === "response.output_text.delta" ||
+                    type === "response.refusal.delta" ||
                     type === "response.function_call_arguments.delta") &&
                     typeof event.delta === "string" &&
                     event.delta.length > 0) {
-                    evidence.firstUsefulOutputAt ??= Date.now();
+                    if (evidence.firstUsefulOutputAt === undefined) {
+                        evidence.firstUsefulOutputAt = Date.now();
+                        evidence.firstUsefulOutputEvent = String(type);
+                    }
+                }
+                // Some clients/providers emit complete output items without deltas.
+                // Reasoning/control events are not useful client output. Recognize
+                // actual tool calls and text only, without inventing an earlier time.
+                const usefulItem = usefulOutputItem(event.item);
+                const completedResponse = event.response;
+                const usefulCompletion = type === "response.completed" &&
+                    completedResponse &&
+                    typeof completedResponse === "object" &&
+                    "output" in completedResponse &&
+                    Array.isArray(completedResponse.output) &&
+                    completedResponse.output.some(usefulOutputItem);
+                const usefulDone = (type === "response.output_text.done" &&
+                    typeof event.text === "string" &&
+                    event.text.length > 0) ||
+                    (type === "response.refusal.done" &&
+                        typeof event.refusal === "string" &&
+                        event.refusal.length > 0) ||
+                    (type === "response.function_call_arguments.done" &&
+                        typeof event.arguments === "string" &&
+                        event.arguments.length > 0) ||
+                    (type === "response.custom_tool_call_input.done" &&
+                        typeof event.input === "string" &&
+                        event.input.length > 0) ||
+                    ((type === "response.content_part.added" ||
+                        type === "response.content_part.done") &&
+                        usefulOutputItem(event.part));
+                const usefulToolDelta = type === "response.custom_tool_call_input.delta" &&
+                    typeof event.delta === "string" &&
+                    event.delta.length > 0;
+                if (evidence.firstUsefulOutputAt === undefined &&
+                    (usefulDone ||
+                        usefulCompletion ||
+                        usefulToolDelta ||
+                        ((type === "response.output_item.added" ||
+                            type === "response.output_item.done") &&
+                            usefulItem))) {
+                    evidence.firstUsefulOutputAt = Date.now();
+                    evidence.firstUsefulOutputEvent = String(type);
                 }
                 if (type === "response.completed") {
                     evidence.completed = true;
@@ -222,6 +297,7 @@ export function createCodexUsageTap() {
             }
             catch {
                 // Unknown frames cannot establish successful completion.
+                evidence.observationIncomplete = true;
             }
         }
     };
@@ -268,16 +344,21 @@ export function createCodexUsageTap() {
                 carry = remainder;
                 inspectEvidence(events);
                 if (carry.length > CARRY_LIMIT_CHARS) {
+                    evidence.observationIncomplete = true;
                     carry = carry.slice(-2);
                     discardingEvent = true;
                 }
             }
             catch {
                 // Telemetry must never break the relay.
+                evidence.observationIncomplete = true;
             }
         },
         flush() {
             // An event without its dispatch delimiter is incomplete on the wire.
+            if (discardingEvent || carry.trim()) {
+                evidence.observationIncomplete = true;
+            }
             settle(latest);
         },
         /**

package/dist/proxy/otelLogSink.d.ts

@@ -34,6 +34,18 @@ export declare function getProxyOtelLogSnapshot(): {
         maxPendingBytes: number;
     };
     queues: {
+        recentFailures: {
+            records: {
+                eventId: string;
+                kind?: string;
+                requestId?: string;
+                captureId?: string;
+            }[];
+            id: string;
+            at: string;
+            reason: "export_unconfirmed" | "queue_full";
+            error?: string;
+        }[];
         attempted: number;
         submitted: number;
         transportAcknowledged: number;
@@ -43,6 +55,7 @@ export declare function getProxyOtelLogSnapshot(): {
         lastAcknowledgedAt: string | undefined;
         lastFailureAt: string | undefined;
         highWaterOutstanding: number;
+        failureHistoryEvicted: number;
         kind: "metadata" | "bodies";
         capacity: number;
     }[];