@juspay/neurolink 12.14.0 → 12.14.1

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

@@ -88,5 +88,6 @@ export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;
 export declare const proxyTelemetryCommand: CommandModule<object, ProxyTelemetryArgs>;
 export declare const proxyGuardCommand: CommandModule<object, ProxyGuardArgs>;
 export declare const proxySetupCommand: CommandModule;
+export declare function buildProxyLaunchdPlist(port: number, host: string, envFile?: string, configFile?: string): string;
 export declare const proxyInstallCommand: CommandModule;
 export declare const proxyUninstallCommand: CommandModule;

package/dist/cli/commands/proxy.js

@@ -1,14 +1,5 @@
-/**
- * Proxy CLI Commands for NeuroLink
- *
- * Implements commands for managing the Claude multi-account proxy:
- * - neurolink proxy start  — Start the proxy server
- * - neurolink proxy status — Show proxy status (accounts, sessions, routing)
- *
- * The proxy creates a NeuroLink instance and builds a Hono app that registers
- * Claude-compatible proxy routes. All requests flow through ctx.neurolink
- * (generate/stream), with an optional ModelRouter for model remapping.
- */
+import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -2398,6 +2389,8 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
+            await flushProxyOtelLogs();
+            await shutdownProxyOtelLogs();
             await flushOpenTelemetry();
             await shutdownOpenTelemetry();
         }
@@ -2758,6 +2751,9 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    await loadProxyStartEnv(argv, spinner);
+    initializeProxyOtelLogs("supervisor");
+    routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
     const entryScript = process.argv[1];
     if (!entryScript) {
@@ -2871,6 +2867,8 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         updaterSupervisor.stop();
         await rollingServer.close();
         await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
+        await flushProxyOtelLogs().catch(() => undefined);
+        await shutdownProxyOtelLogs().catch(() => undefined);
         const supervisorState = loadProxySupervisorState();
         if (supervisorState?.pid === process.pid) {
             clearProxySupervisorState();
@@ -2951,6 +2949,8 @@ async function startProxyCommandHandler(argv) {
             env: baseEnv,
         });
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
+        initializeProxyOtelLogs("worker");
+        routeProxyConsoleToOtel();
         // Reuse upstream TCP connections (longer keep-alive + bounded pool) instead
         // of opening a new flow per request — cuts outbound flow churn through host
         // content-filters. Runs once, after env load so it can be tuned via env.
@@ -3592,7 +3592,9 @@ export const proxyGuardCommand = {
             default: true,
         });
     },
-    handler: async (argv) => {
+    handler: withProxyOtelLogShutdown(async (argv) => {
+        initializeProxyOtelLogs("updater");
+        routeProxyConsoleToOtel();
         const host = argv.host ?? "127.0.0.1";
         const port = argv.port ?? 55669;
         const parentPid = Number(argv.parentPid);
@@ -3916,6 +3918,8 @@ export const proxyGuardCommand = {
                     logger.always(`[updater] update successful: now running ${result.latestVersion}`);
                     persistUpdaterState("record successful update", () => recordSuccessfulUpdate(result.latestVersion));
                     // The replacement proxy starts a worker running the new version.
+                    await flushProxyOtelLogs().catch(() => undefined);
+                    await shutdownProxyOtelLogs().catch(() => undefined);
                     process.exit(0);
                 }
                 else {
@@ -4083,7 +4087,7 @@ export const proxyGuardCommand = {
         if (cleared && !argv.quiet) {
             logger.always(`[proxy] fail-open guard removed stale ${expectedBaseUrl} from Claude settings`);
         }
-    },
+    }),
 };
 // =============================================================================
 // PROXY SETUP COMMAND
@@ -4257,7 +4261,7 @@ function buildLaunchdPath() {
     }
     return [...segments].join(":");
 }
-function buildPlist(port, host, envFile, configFile) {
+export function buildProxyLaunchdPlist(port, host, envFile, configFile) {
     // The plist invokes the trampoline script (a tiny shell wrapper at
     // ~/.neurolink/bin/neurolink-proxy) which re-resolves the real
     // `neurolink` binary via PATH on every launch.  This way, launchd
@@ -4273,6 +4277,20 @@ function buildPlist(port, host, envFile, configFile) {
     <string>--config</string>
     <string>${escapeXml(configFile)}</string>`
         : "";
+    const otelEnvironment = isProxyOtelOnly()
+        ? [
+            "NEUROLINK_PROXY_LOG_SINK",
+            "OTEL_EXPORTER_OTLP_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT",
+            "OTEL_EXPORTER_OTLP_HEADERS",
+            "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+            "OTEL_SERVICE_NAME",
+            "NEUROLINK_PROXY_SESSION_SECRET",
+        ]
+            .filter((name) => process.env[name] !== undefined)
+            .map((name) => `    <key>${name}</key>\n    <string>${escapeXml(process.env[name])}</string>`)
+            .join("\n")
+        : "";
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
   "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -4311,10 +4329,10 @@ ${configArgs}
   <integer>45</integer>
 
   <key>StandardOutPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>
 
   <key>StandardErrorPath</key>
-  <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
+  <string>${isProxyOtelOnly() ? "/dev/null" : join(homedir(), ".neurolink", "logs", "proxy-launchd-stderr.log")}</string>
 
   <key>EnvironmentVariables</key>
   <dict>
@@ -4322,6 +4340,7 @@ ${configArgs}
     <string>${buildLaunchdPath()}</string>
     <key>HOME</key>
     <string>${homedir()}</string>
+${otelEnvironment}
   </dict>
 </dict>
 </plist>`;
@@ -4362,7 +4381,7 @@ export const proxyInstallCommand = {
             console.info(chalk.yellow("On Linux, use systemd. On Windows, use Task Scheduler."));
             process.exit(1);
         }
-        const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+        const { mkdirSync, existsSync, chmodSync } = await import("fs");
         const envResolution = resolveProxyEnvFile({
             explicitEnvFile: argv.envFile,
         });
@@ -4378,8 +4397,9 @@ export const proxyInstallCommand = {
             console.info(chalk.red(`Proxy env file not found: ${envFile}`));
             process.exit(1);
         }
+        await loadProxyEnvFile({ explicitEnvFile: envFile });
         const logsDir = join(homedir(), ".neurolink", "logs");
-        if (!existsSync(logsDir)) {
+        if (!isProxyOtelOnly() && !existsSync(logsDir)) {
             mkdirSync(logsDir, { recursive: true });
         }
         if (!existsSync(PLIST_DIR)) {
@@ -4403,8 +4423,9 @@ export const proxyInstallCommand = {
             process.exit(1);
         }
         console.info(chalk.green(`✓ Trampoline validated (resolves to neurolink v${trampolineVersion})`));
-        const plist = buildPlist(port, host, envFile, configFile);
-        writeFileSync(PLIST_PATH, plist, "utf-8");
+        const plist = buildProxyLaunchdPlist(port, host, envFile, configFile);
+        await writeFileAtomic(PLIST_PATH, plist, 0o600);
+        chmodSync(PLIST_PATH, 0o600);
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));
         if (envFile) {
             console.info(chalk.green(`✓ Proxy env file: ${envFile}`));

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -19,4 +19,4 @@ export declare function redactProxyHeadersForLogging(headers: Record<string, str
  * Process a capture in the worker and retain redacted output when artifact
  * persistence fails.
  */
-export declare function processProxyBodyCapture(entry: ProxyBodyCaptureEntry, logDir: string): Promise<ProcessedProxyBodyCapture>;
+export declare function processProxyBodyCapture(entry: ProxyBodyCaptureEntry, logDir: string | null): Promise<ProcessedProxyBodyCapture>;

package/dist/proxy/bodyCaptureProcessing.js

@@ -203,6 +203,16 @@ export function redactProxyHeadersForLogging(headers) {
 export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
     const prepared = prepareRedactedBody(entry.body);
+    if (logDir === null) {
+        return {
+            headers,
+            stored: {
+                redactedBody: prepared.value,
+                redactedBodyBytes: prepared.bytes,
+                bodyTruncated: prepared.truncated,
+            },
+        };
+    }
     let stored;
     try {
         stored = await writeBodyArtifact(logDir, entry, headers, prepared.value, prepared.truncated);

package/dist/proxy/bodyCaptureWorker.d.ts

@@ -1,7 +1,7 @@
 import type { ProcessedProxyBodyCapture, ProxyBodyCaptureEntry, ProxyBodyCaptureWorkerSnapshot } from "../types/index.js";
 export declare const PROXY_BODY_CAPTURE_DEADLINE_MS = 20000;
 /** Bounded bulk capture. Failures are indexed; never fall back to blocking work. */
-export declare function captureProxyBody(entry: ProxyBodyCaptureEntry, logDir: string, consume: (result: ProcessedProxyBodyCapture) => Promise<void>): Promise<void>;
+export declare function captureProxyBody(entry: ProxyBodyCaptureEntry, logDir: string | null, consume: (result: ProcessedProxyBodyCapture) => Promise<void>): Promise<void>;
 /**
  * Return independent counters for processing, rejection, failure, and
  * retained publication work.

package/dist/proxy/logCleanupScheduler.js

@@ -1,3 +1,4 @@
+import { isProxyOtelOnly } from "./otelLogSink.js";
 import { Worker } from "node:worker_threads";
 import { withTimeout } from "../utils/async/withTimeout.js";
 import { logger } from "../utils/logger.js";
@@ -9,6 +10,9 @@ const WORKER_TERMINATION_TIMEOUT_MS = 5_000;
  * block active streams. Concurrent runs are coalesced into the active scan.
  */
 export function startProxyLogCleanupScheduler(params) {
+    if (isProxyOtelOnly()) {
+        return { trigger: () => false, stop: async () => { } };
+    }
     const maxAgeDays = params.maxAgeDays ?? 7;
     const maxSizeMb = params.maxSizeMb ?? 500;
     let activeWorker;

package/dist/proxy/otelLogSink.d.ts

@@ -0,0 +1,34 @@
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+/** Explicit opt-in; configuration never silently falls back to file logging. */
+export declare function isProxyOtelOnly(): boolean;
+/** Initialize a log-only provider in every proxy process, including the supervisor. */
+export declare function initializeProxyOtelLogs(role?: string): LoggerProvider | undefined;
+/** Structured evidence without final-request dashboard fields on auxiliary events. */
+export declare function emitProxyOtelEvent(kind: string, record: Record<string, unknown>): void;
+/** Capture application console diagnostics only inside proxy service processes. */
+export declare function routeProxyConsoleToOtel(): void;
+/** Counters acknowledge collector transport only, never backend persistence. */
+export declare function getProxyOtelLogSnapshot(): {
+    mode: string;
+    initialized: boolean;
+    deliveryGuarantee: string;
+    invalidRecords: number;
+    queues: {
+        attempted: number;
+        submitted: number;
+        transportAcknowledged: number;
+        exportUnconfirmed: number;
+        dropped: number;
+        outstanding: number;
+        lastAcknowledgedAt: string | undefined;
+        lastFailureAt: string | undefined;
+        kind: string;
+        capacity: number;
+    }[];
+};
+/** Bounded provider flush belongs after final request and lifecycle publication. */
+export declare function flushProxyOtelLogs(): Promise<void>;
+/** Release this process's exporter and restore console ownership. */
+export declare function shutdownProxyOtelLogs(): Promise<void>;
+/** Flush short-lived proxy command diagnostics on every normal return or exception. */
+export declare function withProxyOtelLogShutdown<TArg>(handler: (arg: TArg) => Promise<void>): (arg: TArg) => Promise<void>;

package/dist/proxy/otelLogSink.js

@@ -0,0 +1,254 @@
+/* eslint-disable no-console -- This proxy-only sink replaces console methods with OTLP emission. */
+import { inspect } from "node:util";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ExportResultCode } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { sanitizeForLog } from "../utils/logSanitize.js";
+let provider;
+let restoreConsole;
+const queues = [];
+/** Explicit opt-in; configuration never silently falls back to file logging. */
+export function isProxyOtelOnly() {
+    return process.env.NEUROLINK_PROXY_LOG_SINK === "otel";
+}
+/** Reserve capacity including exports in flight, independently for metadata and bodies. */
+function createTrackedProcessor(url, capacity) {
+    const state = {
+        attempted: 0,
+        submitted: 0,
+        transportAcknowledged: 0,
+        exportUnconfirmed: 0,
+        dropped: 0,
+        outstanding: 0,
+        lastAcknowledgedAt: undefined,
+        lastFailureAt: undefined,
+    };
+    const transport = new OTLPLogExporter({ url, timeoutMillis: 5000 });
+    const exporter = {
+        export(records, callback) {
+            let settled = false;
+            const settle = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                state.outstanding -= records.length;
+                if (result.code === ExportResultCode.SUCCESS) {
+                    state.transportAcknowledged += records.length;
+                    state.lastAcknowledgedAt = new Date().toISOString();
+                }
+                else {
+                    state.exportUnconfirmed += records.length;
+                    state.lastFailureAt = new Date().toISOString();
+                }
+                callback(result);
+            };
+            try {
+                transport.export(records, settle);
+            }
+            catch (error) {
+                settle({
+                    code: ExportResultCode.FAILED,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                });
+            }
+        },
+        shutdown: () => transport.shutdown(),
+    };
+    const batch = new BatchLogRecordProcessor(exporter, {
+        maxQueueSize: capacity,
+        maxExportBatchSize: 64,
+        scheduledDelayMillis: 1000,
+        exportTimeoutMillis: 6000,
+    });
+    const processor = {
+        onEmit(record) {
+            state.attempted++;
+            if (state.outstanding >= capacity) {
+                state.dropped++;
+                return;
+            }
+            state.submitted++;
+            state.outstanding++;
+            batch.onEmit(record);
+        },
+        forceFlush: () => batch.forceFlush(),
+        shutdown: () => batch.shutdown(),
+    };
+    return { state, processor, capacity };
+}
+/** Initialize a log-only provider in every proxy process, including the supervisor. */
+export function initializeProxyOtelLogs(role = "worker") {
+    if (!isProxyOtelOnly()) {
+        return undefined;
+    }
+    if (provider) {
+        return provider;
+    }
+    const endpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT ??
+        (process.env.OTEL_EXPORTER_OTLP_ENDPOINT
+            ? `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT.replace(/\/$/, "")}/v1/logs`
+            : undefined);
+    if (!endpoint) {
+        throw new Error("OTel-only proxy logging requires an OTLP endpoint");
+    }
+    const url = new URL(endpoint);
+    if (!["http:", "https:"].includes(url.protocol)) {
+        throw new Error("Proxy OTLP logs endpoint must use HTTP or HTTPS");
+    }
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol === "http:" && !loopback) {
+        throw new Error("Proxy OTLP logs require HTTPS for non-loopback collectors");
+    }
+    const metadata = createTrackedProcessor(endpoint, 2048);
+    const bodies = createTrackedProcessor(endpoint, 256);
+    queues.push(metadata, bodies);
+    provider = new LoggerProvider({
+        resource: resourceFromAttributes({
+            "service.name": process.env.OTEL_SERVICE_NAME ?? "neurolink-proxy",
+            "service.instance.id": `${role}-${process.pid}`,
+            "process.pid": process.pid,
+            "proxy.process.role": role,
+        }),
+        processors: [
+            {
+                onEmit(record, context) {
+                    (record.attributes?.["proxy.record_kind"] === "body"
+                        ? bodies
+                        : metadata).processor.onEmit(record, context);
+                },
+                forceFlush: async () => {
+                    await Promise.all(queues.map((q) => q.processor.forceFlush()));
+                },
+                shutdown: async () => {
+                    await Promise.all(queues.map((q) => q.processor.shutdown()));
+                },
+            },
+        ],
+    });
+    return provider;
+}
+/** Structured evidence without final-request dashboard fields on auxiliary events. */
+export function emitProxyOtelEvent(kind, record) {
+    if (!isProxyOtelOnly()) {
+        return;
+    }
+    try {
+        initializeProxyOtelLogs()
+            ?.getLogger("neurolink-proxy-events")
+            .emit({
+            severityNumber: SeverityNumber.INFO,
+            severityText: "INFO",
+            body: JSON.stringify(record),
+            attributes: {
+                "proxy.record_kind": kind,
+                "event.name": `proxy.${kind}`,
+                ...(typeof record.requestId === "string"
+                    ? { "request.id": record.requestId }
+                    : {}),
+                ...(typeof record.event === "string"
+                    ? { "proxy.lifecycle.event": record.event }
+                    : {}),
+            },
+        });
+    }
+    catch {
+        // Telemetry must never fail a model request. Invalid records are observable.
+        invalidRecords++;
+    }
+}
+let invalidRecords = 0;
+/** Capture application console diagnostics only inside proxy service processes. */
+export function routeProxyConsoleToOtel() {
+    if (!isProxyOtelOnly() || restoreConsole) {
+        return;
+    }
+    initializeProxyOtelLogs();
+    const originals = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+    };
+    let emitting = false;
+    for (const level of Object.keys(originals)) {
+        console[level] = (...args) => {
+            if (emitting) {
+                return;
+            }
+            emitting = true;
+            try {
+                const body = args
+                    .map((value) => typeof value === "string"
+                    ? value
+                    : inspect(value, {
+                        depth: 4,
+                        maxArrayLength: 30,
+                        maxStringLength: 16000,
+                    }))
+                    .join(" ");
+                provider?.getLogger("neurolink-proxy-console").emit({
+                    body: sanitizeForLog(body, 32000),
+                    severityText: level.toUpperCase(),
+                    severityNumber: level === "error"
+                        ? SeverityNumber.ERROR
+                        : level === "warn"
+                            ? SeverityNumber.WARN
+                            : level === "debug"
+                                ? SeverityNumber.DEBUG
+                                : SeverityNumber.INFO,
+                    attributes: { "proxy.record_kind": "console" },
+                });
+            }
+            catch {
+                invalidRecords++;
+            }
+            finally {
+                emitting = false;
+            }
+        };
+    }
+    restoreConsole = () => Object.assign(console, originals);
+}
+/** Counters acknowledge collector transport only, never backend persistence. */
+export function getProxyOtelLogSnapshot() {
+    return {
+        mode: isProxyOtelOnly() ? "otel" : "file-and-otel",
+        initialized: provider !== undefined,
+        deliveryGuarantee: "best-effort; HTTP success is not per-record acceptance or backend persistence",
+        invalidRecords,
+        queues: queues.map((q, index) => ({
+            kind: index === 0 ? "metadata" : "bodies",
+            capacity: q.capacity,
+            ...q.state,
+        })),
+    };
+}
+/** Bounded provider flush belongs after final request and lifecycle publication. */
+export async function flushProxyOtelLogs() {
+    await provider?.forceFlush();
+}
+/** Release this process's exporter and restore console ownership. */
+export async function shutdownProxyOtelLogs() {
+    restoreConsole?.();
+    restoreConsole = undefined;
+    await provider?.shutdown();
+    provider = undefined;
+    queues.length = 0;
+    invalidRecords = 0;
+}
+/** Flush short-lived proxy command diagnostics on every normal return or exception. */
+export function withProxyOtelLogShutdown(handler) {
+    return async (arg) => {
+        try {
+            await handler(arg);
+        }
+        finally {
+            await flushProxyOtelLogs().catch(() => undefined);
+            await shutdownProxyOtelLogs().catch(() => undefined);
+        }
+    };
+}

package/dist/proxy/proxyLifecycle.js

@@ -1,3 +1,4 @@
+import { emitProxyOtelEvent, isProxyOtelOnly, initializeProxyOtelLogs, } from "./otelLogSink.js";
 import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
@@ -297,6 +298,25 @@ export function configureProxyLifecycleLogger(options) {
     batchSize = positiveInteger(options.batchSize, DEFAULT_BATCH_SIZE);
     maxWriteRetries = positiveInteger(options.maxWriteRetries, DEFAULT_MAX_WRITE_RETRIES);
     flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+    if (options.enabled && isProxyOtelOnly()) {
+        initializeProxyOtelLogs(options.filePrefix === "proxy-supervisor" ? "supervisor" : "worker");
+        loggerEnabled = true;
+        sessionHashKey = process.env.NEUROLINK_PROXY_SESSION_SECRET
+            ? createHash("sha256")
+                .update(process.env.NEUROLINK_PROXY_SESSION_SECRET)
+                .digest()
+            : sessionHashKey;
+        stopRuntimeMetrics = startProxyRuntimeMetrics((runtimeSample) => {
+            logProxyLifecycleEvent({
+                event: "runtime_sample",
+                requestId: "-",
+                method: "-",
+                path: "-",
+                runtimeSample,
+            });
+        });
+        return;
+    }
     if (options.enabled && options.logDir) {
         try {
             mkdirSync(options.logDir, { recursive: true, mode: 0o700 });
@@ -336,7 +356,7 @@ export function logProxyLifecycleEvent(input) {
  * capacity is unavailable.
  */
 function enqueueLifecycleEvent(input, onPersisted) {
-    if (!loggerEnabled || !lifecycleLogDir) {
+    if (!loggerEnabled || (!lifecycleLogDir && !isProxyOtelOnly())) {
         onPersisted?.(false);
         return;
     }
@@ -406,6 +426,10 @@ function enqueueLifecycleEvent(input, onPersisted) {
                 : {}),
             ...(input.runtimeSample ? { runtimeSample: input.runtimeSample } : {}),
         };
+        if (isProxyOtelOnly()) {
+            emitProxyOtelEvent(filePrefix === "proxy-supervisor" ? "supervisor" : "lifecycle", record);
+            return;
+        }
         queue.push({
             filePrefix,
             logDir: lifecycleLogDir,
@@ -431,6 +455,10 @@ export async function persistProxyLifecycleAcceptance(input, timeoutMs = LIFECYC
     if (!loggerRequired) {
         return;
     }
+    if (isProxyOtelOnly()) {
+        enqueueLifecycleEvent({ ...input, event: "request_accepted" });
+        return;
+    }
     const confirmed = new Promise((resolve) => {
         enqueueLifecycleEvent({ ...input, event: "request_accepted" }, resolve);
     });
@@ -462,6 +490,8 @@ export async function flushProxyLifecycleEvents(timeoutMs = 5_000) {
 export function getProxyLifecycleLoggerSnapshot() {
     return {
         enabled: loggerEnabled,
+        sink: isProxyOtelOnly() ? "otel" : "file",
+        admissionPolicy: isProxyOtelOnly() ? "best-effort" : "durable-file",
         schemaVersion: SCHEMA_VERSION,
         processInstanceId,
         nextSequence,