@juspay/neurolink 12.14.13 → 12.14.15

package/dist/cli/commands/proxy.js

@@ -544,6 +544,33 @@ async function fetchProxyHealthVersion(host, port) {
         return undefined;
     }
 }
+/** Read both serving generations so an updated worker cannot hide a stale parent. */
+async function fetchProxyRuntimeVersions(host, port) {
+    try {
+        const response = await fetch(`http://${host}:${port}/status`, {
+            headers: { connection: "close" },
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!response.ok) {
+            return {};
+        }
+        const data = (await response.json());
+        return {
+            ...(typeof data.version === "string"
+                ? { workerVersion: data.version }
+                : {}),
+            ...(typeof data.autoUpdate?.supervisorVersion === "string"
+                ? { supervisorVersion: data.autoUpdate.supervisorVersion }
+                : {}),
+            ...(typeof data.autoUpdate?.supervisorPid === "number"
+                ? { supervisorPid: data.autoUpdate.supervisorPid }
+                : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 /**
  * After a failed rolling update, re-point the live supervisor at the reinstalled
  * running version (mirroring the forward path: record the pending target, then
@@ -576,7 +603,7 @@ async function activateRollbackVersion(host, port, parentPid, runningVersion, ti
         abandonPendingUpdate(runningVersion);
     }
 }
-async function setProxyUpdateDrain(host, port, draining) {
+async function setProxyUpdateDrain(host, port, draining, supervisorRefresh = false) {
     const confirmState = async () => {
         try {
             const response = await fetch(`http://${host}:${port}/status`, {
@@ -599,7 +626,13 @@ async function setProxyUpdateDrain(host, port, draining) {
                 "content-type": "application/json",
                 "x-neurolink-update-token": PROXY_UPDATE_CONTROL_TOKEN,
             },
-            body: JSON.stringify({ action: draining ? "drain" : "resume" }),
+            body: JSON.stringify({
+                action: draining
+                    ? supervisorRefresh
+                        ? "drain_for_supervisor_refresh"
+                        : "drain"
+                    : "resume",
+            }),
             signal: AbortSignal.timeout(5_000),
         });
         if (!response.ok) {
@@ -1426,6 +1459,22 @@ export async function createProxyStartApp(params) {
             },
         }, status);
     });
+    let supervisorRefreshDrainLease;
+    const scheduleSupervisorRefreshResume = (delayMs) => {
+        clearTimeout(supervisorRefreshDrainLease);
+        const resumeWhenReady = () => {
+            if (resumeProxyConnections(readiness)) {
+                supervisorRefreshDrainLease = undefined;
+                return;
+            }
+            // Readiness can be transiently false during worker replacement. Keep a
+            // recovery lease until admission has actually reopened.
+            supervisorRefreshDrainLease = setTimeout(resumeWhenReady, 30_000);
+            supervisorRefreshDrainLease.unref?.();
+        };
+        supervisorRefreshDrainLease = setTimeout(resumeWhenReady, delayMs);
+        supervisorRefreshDrainLease.unref?.();
+    };
     app.post("/internal/update-control", async (c) => {
         const suppliedToken = c.req.header("x-neurolink-update-token");
         const expectedToken = params.updateControlToken ?? PROXY_UPDATE_CONTROL_TOKEN;
@@ -1435,11 +1484,13 @@ export async function createProxyStartApp(params) {
         const payload = await c.req
             .json()
             .catch(() => ({ action: undefined }));
-        if (payload.action === "drain") {
+        if (payload.action === "drain" ||
+            payload.action === "drain_for_supervisor_refresh") {
             // 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()) {
+            if (isProxySocketWorkerProcess() &&
+                payload.action !== "drain_for_supervisor_refresh") {
                 return c.json({
                     error: "rolling_restart_required",
                     message: "Use neurolink proxy restart; global update drain is disabled for rolling workers.",
@@ -1448,11 +1499,18 @@ export async function createProxyStartApp(params) {
             if (!markProxyDrainingForUpdate(readiness)) {
                 return c.json({ error: "proxy_not_ready" }, 409);
             }
+            if (payload.action === "drain_for_supervisor_refresh") {
+                // A crashed updater must not strand the current rolling worker in
+                // maintenance mode. A successful launchd refresh replaces this process.
+                scheduleSupervisorRefreshResume(35 * 60 * 1000);
+            }
         }
         else if (payload.action === "resume") {
             if (!resumeProxyConnections(readiness)) {
                 return c.json({ error: "proxy_not_ready" }, 409);
             }
+            clearTimeout(supervisorRefreshDrainLease);
+            supervisorRefreshDrainLease = undefined;
         }
         else {
             return c.json({ error: "invalid_action" }, 400);
@@ -3955,8 +4013,6 @@ export const proxyGuardCommand = {
                         return;
                     }
                     persistUpdaterState("record installed update", () => recordUpdateInstalled(result.latestVersion));
-                    updateRetryAttempts = 0;
-                    updateRetryVersion = null;
                     logger.always(`[updater] trampoline validated at v${validation.version} after ${validation.attempts} attempt(s)`);
                 }
                 catch (trampolineError) {
@@ -3973,18 +4029,24 @@ export const proxyGuardCommand = {
                 }
                 updateRestartInProgress = true;
                 if (rollingSupervisor) {
-                    logger.always(`[updater] requesting rolling activation of v${result.latestVersion}`);
-                    try {
-                        process.kill(parentPid, "SIGUSR2");
+                    const activeVersions = await fetchProxyRuntimeVersions(host, port);
+                    if (activeVersions.workerVersion === result.latestVersion) {
+                        logger.always(`[updater] worker v${result.latestVersion} is already active; resuming supervisor refresh without another worker replacement`);
                     }
-                    catch (activationError) {
-                        updateRestartInProgress = false;
-                        const message = activationError instanceof Error
-                            ? activationError.message
-                            : String(activationError);
-                        logger.always(`[updater] WARNING: rolling activation request failed: ${message}`);
-                        persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "restart", message));
-                        return;
+                    else {
+                        logger.always(`[updater] requesting rolling activation of v${result.latestVersion}`);
+                        try {
+                            process.kill(parentPid, "SIGUSR2");
+                        }
+                        catch (activationError) {
+                            updateRestartInProgress = false;
+                            const message = activationError instanceof Error
+                                ? activationError.message
+                                : String(activationError);
+                            logger.always(`[updater] WARNING: rolling activation request failed: ${message}`);
+                            persistUpdaterState("record update failure", () => recordUpdateFailure(result.latestVersion, "restart", message));
+                            return;
+                        }
                     }
                 }
                 else {
@@ -4037,9 +4099,101 @@ export const proxyGuardCommand = {
                         }
                     }
                 }
+                if (healthy && rollingSupervisor) {
+                    const beforeRefresh = await fetchProxyRuntimeVersions(host, port);
+                    if (beforeRefresh.supervisorVersion !== result.latestVersion) {
+                        logger.always(`[updater] worker v${result.latestVersion} is healthy; waiting for a safe supervisor refresh (supervisor v${beforeRefresh.supervisorVersion ?? "unknown"})`);
+                        let lastRefreshDeferral = "";
+                        const waitForSupervisorRefresh = async (quietWaitMs) => {
+                            const window = await waitForProxyUpdateWindow({
+                                quietThresholdMs: QUIET_THRESHOLD_MS,
+                                quietWaitMs,
+                                drainWaitMs: UPDATE_DRAIN_TIMEOUT_MS,
+                                pollIntervalMs: UPDATE_ACTIVITY_POLL_MS,
+                                getActivity: () => getProxyRuntimeActivity(host, port),
+                                setDraining: async (draining) => {
+                                    const changed = await setProxyUpdateDrain(host, port, draining, true);
+                                    if (changed) {
+                                        logger.always(`[updater] ${draining ? "draining new inference requests for supervisor refresh" : "inference admission resumed"}`);
+                                    }
+                                    return changed;
+                                },
+                                isStopping: () => guardStopping,
+                                isParentAlive: () => getProcessStatus(parentPid) !== "not_running",
+                                onPhase: (phase, activity) => {
+                                    const signature = `${phase}:${activity?.activeRequests ?? "unknown"}`;
+                                    if (signature !== lastRefreshDeferral) {
+                                        lastRefreshDeferral = signature;
+                                        persistUpdaterState("record supervisor refresh deferral", () => recordUpdateDeferred(result.latestVersion, phase, activity?.activeRequests ?? null));
+                                    }
+                                    logger.debug(`[updater] supervisor refresh ${phase} (${activity?.activeRequests ?? "unknown"} active requests)`);
+                                },
+                            });
+                            drainActive = drainActive || window.draining;
+                            return window;
+                        };
+                        let refreshWindow = await waitForSupervisorRefresh(NATURAL_WINDOW_WAIT_MS);
+                        // A naturally quiet result still needs a short admission fence to
+                        // close the race between the last activity poll and launchd.
+                        if (refreshWindow.ready && !refreshWindow.draining) {
+                            refreshWindow = await waitForSupervisorRefresh(0);
+                        }
+                        if (!refreshWindow.ready) {
+                            logger.always(`[updater] supervisor refresh deferred: ${refreshWindow.reason ?? "safe window unavailable"}`);
+                            persistUpdaterState("record supervisor refresh deferral", () => recordUpdateDeferred(result.latestVersion, refreshWindow.reason === "drain_timeout"
+                                ? "drain_timeout"
+                                : "drain_unavailable", null));
+                            updateRestartInProgress = false;
+                            scheduleUpdateRetry("supervisor refresh window unavailable", result.latestVersion);
+                            return;
+                        }
+                        logger.always(`[updater] refreshing launchd supervisor at v${result.latestVersion}`);
+                        const uid = process.getuid?.() ?? 501;
+                        try {
+                            execFileSync("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`], { timeout: 10_000, stdio: "pipe" });
+                            // The drained worker belongs to the replaced service. The new
+                            // supervisor starts with admission open.
+                            drainActive = false;
+                        }
+                        catch (refreshError) {
+                            const message = refreshError instanceof Error
+                                ? refreshError.message
+                                : String(refreshError);
+                            logger.always(`[updater] WARNING: supervisor refresh failed: ${message}`);
+                            persistUpdaterState("record supervisor refresh failure", () => recordUpdateFailure(result.latestVersion, "restart", `supervisor refresh failed: ${message}`));
+                            updateRestartInProgress = false;
+                            scheduleUpdateRetry("supervisor refresh failed", result.latestVersion);
+                            return;
+                        }
+                        const refreshStartedAt = Date.now();
+                        const previousSupervisorPid = beforeRefresh.supervisorPid ?? parentPid;
+                        healthy = false;
+                        while (Date.now() - refreshStartedAt < 120_000) {
+                            await sleep(2_000);
+                            const versions = await fetchProxyRuntimeVersions(host, port);
+                            if (versions.workerVersion === result.latestVersion &&
+                                versions.supervisorVersion === result.latestVersion &&
+                                versions.supervisorPid !== undefined &&
+                                versions.supervisorPid !== previousSupervisorPid) {
+                                healthy = true;
+                                break;
+                            }
+                        }
+                        if (!healthy) {
+                            const message = `supervisor did not report v${result.latestVersion} with a new process within 120000ms`;
+                            logger.always(`[updater] WARNING: ${message}`);
+                            persistUpdaterState("record supervisor refresh failure", () => recordUpdateFailure(result.latestVersion, "health", message));
+                            updateRestartInProgress = false;
+                            scheduleUpdateRetry("supervisor refresh health unavailable", result.latestVersion);
+                            return;
+                        }
+                    }
+                }
                 if (healthy) {
                     logger.always(`[updater] update successful: now running ${result.latestVersion}`);
                     persistUpdaterState("record successful update", () => recordSuccessfulUpdate(result.latestVersion));
+                    updateRetryAttempts = 0;
+                    updateRetryVersion = null;
                     // The replacement proxy starts a worker running the new version.
                     await flushProxyOtelLogs().catch(() => undefined);
                     await shutdownProxyOtelLogs().catch(() => undefined);

package/dist/providers/anthropic/client.js

@@ -1317,7 +1317,19 @@ export class AnthropicProvider extends BaseProvider {
                         // stop_reason "tool_use", but no tool call is surfaced, so
                         // reporting "tool-calls" would misread as a step-capped turn.
                         // `raw` still carries the provider's verbatim stop_reason.
-                        unified: finalResultText !== undefined
+                        //
+                        // Only "tool-calls" is substituted, never every reason. The turn
+                        // can also end at stop_reason "max_tokens" — the model was still
+                        // writing the final_result arguments when the output ceiling hit,
+                        // so the structured payload is cut mid-JSON. Reporting that as
+                        // "stop" told the caller the response was complete: neurolink.ts's
+                        // `finishReason === "length"` check never fired, so `jsonTruncated`
+                        // stayed unset and no truncation warning was logged, leaving a
+                        // partial object indistinguishable from a whole one. This mirrors
+                        // the streaming path, which already narrows the same substitution
+                        // to a "tool-calls" reason.
+                        unified: finalResultText !== undefined &&
+                            mapAnthropicStopReason(response.stop_reason) === "tool-calls"
                             ? "stop"
                             : mapAnthropicStopReason(response.stop_reason),
                         raw: response.stop_reason ?? "stop",

package/dist/proxy/otelLogSink.js

@@ -14,8 +14,13 @@ let provider;
 let restoreConsole;
 const queues = [];
 const bodyPublications = new Map();
+const bodyPublicationDeadlines = new WeakMap();
 let bodyPublicationChain = Promise.resolve();
 let shuttingDown = false;
+const BODY_OTLP_CHUNK_SIZE = 128 * 1024;
+const OTLP_EXPORT_TIMEOUT_MS = 30_000;
+const OTLP_EXPORT_CALLBACK_DEADLINE_MS = OTLP_EXPORT_TIMEOUT_MS + 1_000;
+const BODY_PUBLICATION_ACTIVE_DEADLINE_MS = 20_000;
 const bodyDelivery = {
     attempted: 0,
     transportAcknowledged: 0,
@@ -94,14 +99,17 @@ function createTrackedProcessor(url, capacity, kind) {
             }
         });
     };
-    const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
+    const transport = new OTLPLogExporter({
+        url,
+        timeoutMillis: OTLP_EXPORT_TIMEOUT_MS,
+    });
     const exporter = {
         export(records, callback) {
             let settled = false;
             const deadline = setTimeout(() => settle({
                 code: ExportResultCode.FAILED,
                 error: new Error("OTLP export callback deadline exceeded"),
-            }), 6_000);
+            }), OTLP_EXPORT_CALLBACK_DEADLINE_MS);
             deadline.unref();
             const settle = (result) => {
                 if (settled) {
@@ -125,7 +133,9 @@ function createTrackedProcessor(url, capacity, kind) {
                     const id = record.attributes?.["body.capture_id"];
                     const publication = typeof id === "string" ? bodyPublications.get(id) : undefined;
                     if (publication) {
-                        if (result.code === ExportResultCode.SUCCESS) {
+                        const activeDeadline = bodyPublicationDeadlines.get(publication);
+                        if (result.code === ExportResultCode.SUCCESS &&
+                            (activeDeadline === undefined || Date.now() < activeDeadline)) {
                             publication.acknowledged++;
                         }
                         else {
@@ -155,7 +165,7 @@ function createTrackedProcessor(url, capacity, kind) {
         maxQueueSize: capacity,
         maxExportBatchSize: 64,
         scheduledDelayMillis: 1000,
-        exportTimeoutMillis: 6000,
+        exportTimeoutMillis: OTLP_EXPORT_CALLBACK_DEADLINE_MS,
     });
     const processor = {
         onEmit(record) {
@@ -247,21 +257,25 @@ export async function publishProxyOtelBody(captureId, body, emit) {
         emitted: 0,
     };
     bodyPublications.set(captureId, progress);
-    const deadline = Date.now() + 20_000;
+    let deferredRelease;
     const operation = bodyPublicationChain.then(async () => {
         const queue = queues.find((candidate) => candidate.kind === "bodies");
-        if (!queue || Date.now() >= deadline) {
+        if (!queue) {
             return {
                 status: "rejected",
                 acknowledgedChunks: 0,
                 unconfirmedChunks: 0,
                 droppedChunks: 0,
-                reason: !queue
-                    ? "body_exporter_unavailable"
-                    : "body_publication_deadline",
+                reason: "body_exporter_unavailable",
             };
         }
-        const chunks = splitUtf8StringByBytes(body, 16_000);
+        // A capture owns bounded publication memory while waiting behind earlier
+        // captures. Start its active deadline only when it reaches the head of
+        // the chain; healthy queued captures must not expire solely because an
+        // earlier export used its transport timeout.
+        const deadline = Date.now() + BODY_PUBLICATION_ACTIVE_DEADLINE_MS;
+        bodyPublicationDeadlines.set(progress, deadline);
+        const chunks = splitUtf8StringByBytes(body, BODY_OTLP_CHUNK_SIZE);
         const awaitSettlement = () => new Promise((resolve) => {
             const check = () => {
                 if (progress.acknowledged + progress.unconfirmed + progress.dropped >=
@@ -273,6 +287,60 @@ export async function publishProxyOtelBody(captureId, body, emit) {
             progress.notify = check;
             check();
         });
+        const resultFromProgress = (snapshot, reason) => {
+            const pending = Math.max(0, snapshot.emitted -
+                snapshot.acknowledged -
+                snapshot.unconfirmed -
+                snapshot.dropped);
+            const unconfirmedChunks = snapshot.unconfirmed + pending;
+            const status = snapshot.emitted === 0 && chunks.length > 0
+                ? "rejected"
+                : snapshot.dropped || snapshot.emitted !== chunks.length
+                    ? "partial"
+                    : unconfirmedChunks
+                        ? "export_unconfirmed"
+                        : "transport_acknowledged";
+            return {
+                status,
+                expectedChunks: chunks.length,
+                acknowledgedChunks: snapshot.acknowledged,
+                unconfirmedChunks,
+                droppedChunks: snapshot.dropped,
+                notSubmittedChunks: chunks.length - snapshot.emitted,
+                ...(reason ? { reason } : {}),
+            };
+        };
+        const settleCurrentBatch = async () => {
+            const currentProgress = () => ({
+                acknowledged: progress.acknowledged,
+                unconfirmed: progress.unconfirmed,
+                dropped: progress.dropped,
+                emitted: progress.emitted,
+            });
+            const settlement = queue.processor.forceFlush().then(awaitSettlement);
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0) {
+                deferredRelease = settlement.catch(() => undefined);
+                return resultFromProgress(currentProgress(), "body_publication_deadline");
+            }
+            let timer;
+            const completed = await Promise.race([
+                settlement.then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), remainingMs);
+                    timer.unref?.();
+                }),
+            ]).finally(() => clearTimeout(timer));
+            if (!completed || Date.now() >= deadline) {
+                if (!completed) {
+                    // The exporter callback owns the submitted records until it settles.
+                    // Keep the capture identity and memory reservation alive meanwhile.
+                    deferredRelease = settlement.catch(() => undefined);
+                }
+                return resultFromProgress(currentProgress(), "body_publication_deadline");
+            }
+            return undefined;
+        };
         let reason;
         try {
             for (let offset = 0; offset < chunks.length; offset += 64) {
@@ -283,16 +351,18 @@ export async function publishProxyOtelBody(captureId, body, emit) {
                 // Ordinary body records from an external logger may share this queue.
                 // Wait for them before admitting any part of this batch.
                 while (queue.state.outstanding > queue.capacity - 64) {
-                    await queue.processor.forceFlush();
-                    if (Date.now() >= deadline) {
-                        throw new Error("body_publication_deadline");
+                    const deadlineResult = await settleCurrentBatch();
+                    if (deadlineResult) {
+                        return deadlineResult;
                     }
                 }
                 for (let i = offset; i < Math.min(offset + 64, chunks.length); i++) {
                     emit(chunks[i], i, chunks.length);
                 }
-                await queue.processor.forceFlush();
-                await awaitSettlement();
+                const deadlineResult = await settleCurrentBatch();
+                if (deadlineResult) {
+                    return deadlineResult;
+                }
                 if (progress.unconfirmed || progress.dropped) {
                     reason = "body_export_unconfirmed";
                     break;
@@ -306,26 +376,32 @@ export async function publishProxyOtelBody(captureId, body, emit) {
                     error.message === "body_publication_deadline"
                     ? "body_publication_deadline"
                     : "body_publication_failed";
-            // Retain ownership of already submitted chunks until their callbacks settle.
-            await queue.processor.forceFlush().catch(() => undefined);
-            await awaitSettlement();
+            // Do not let error cleanup hold the serial publication chain past this
+            // capture's deadline. Exporter callbacks still own submitted chunks, so
+            // retain the capture identity and memory reservation until they settle.
+            const settlement = queue.processor
+                .forceFlush()
+                .catch(() => undefined)
+                .then(awaitSettlement);
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0) {
+                deferredRelease = settlement;
+            }
+            else {
+                let timer;
+                const completed = await Promise.race([
+                    settlement.then(() => true),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve(false), remainingMs);
+                        timer.unref?.();
+                    }),
+                ]).finally(() => clearTimeout(timer));
+                if (!completed) {
+                    deferredRelease = settlement;
+                }
+            }
         }
-        const status = progress.emitted === 0 && chunks.length > 0
-            ? "rejected"
-            : progress.dropped || progress.emitted !== chunks.length
-                ? "partial"
-                : progress.unconfirmed
-                    ? "export_unconfirmed"
-                    : "transport_acknowledged";
-        return {
-            status,
-            expectedChunks: chunks.length,
-            acknowledgedChunks: progress.acknowledged,
-            unconfirmedChunks: progress.unconfirmed,
-            droppedChunks: progress.dropped,
-            notSubmittedChunks: chunks.length - progress.emitted,
-            ...(reason ? { reason } : {}),
-        };
+        return resultFromProgress(progress, reason);
     });
     bodyPublicationChain = operation.then(() => undefined, () => undefined);
     try {
@@ -345,9 +421,17 @@ export async function publishProxyOtelBody(captureId, body, emit) {
         return result;
     }
     finally {
-        bodyPublications.delete(captureId);
-        bodyDelivery.pending--;
-        bodyDelivery.pendingBytes -= bytes;
+        const release = () => {
+            bodyPublications.delete(captureId);
+            bodyDelivery.pending--;
+            bodyDelivery.pendingBytes -= bytes;
+        };
+        if (deferredRelease) {
+            void deferredRelease.finally(release);
+        }
+        else {
+            release();
+        }
     }
 }
 /** Initialize a log-only provider in every proxy process, including the supervisor. */

package/dist/proxy/proxyLifecycle.js

@@ -30,6 +30,7 @@ let processInstanceId = randomUUID();
 let sessionHashKey = randomBytes(32);
 let nextSequence = 1;
 let attempted = 0;
+let otelSubmitted = 0;
 let enqueued = 0;
 let written = 0;
 let dropped = 0;
@@ -428,6 +429,7 @@ function enqueueLifecycleEvent(input, onPersisted) {
         };
         if (isProxyOtelOnly()) {
             emitProxyOtelEvent(filePrefix === "proxy-supervisor" ? "supervisor" : "lifecycle", record);
+            otelSubmitted += 1;
             return;
         }
         queue.push({
@@ -496,6 +498,7 @@ export function getProxyLifecycleLoggerSnapshot() {
         processInstanceId,
         nextSequence,
         attempted,
+        otelSubmitted,
         enqueued,
         written,
         dropped,
@@ -530,6 +533,7 @@ export function resetProxyLifecycleLoggerForTests() {
     sessionHashKey = randomBytes(32);
     nextSequence = 1;
     attempted = 0;
+    otelSubmitted = 0;
     enqueued = 0;
     written = 0;
     dropped = 0;

package/dist/types/proxy.d.ts

@@ -744,6 +744,8 @@ export type ProxyTelemetryCheck = {
 /** Small stored metadata used by the doctor; bodies are queried separately. */
 export type ProxyTelemetryStoredRecord = Partial<RequestLogEntry> & {
     recordedAtMicroseconds?: number;
+    id?: string;
+    at?: string;
     captureId?: string;
     bodySha256?: string;
     redactedBodyBytes?: number;
@@ -1824,6 +1826,8 @@ export type ProxyLifecycleLoggerSnapshot = {
     processInstanceId: string;
     nextSequence: number;
     attempted: number;
+    /** Records delegated to the OTel sink; delivery is reported by its queues. */
+    otelSubmitted: number;
     enqueued: number;
     written: number;
     dropped: number;