@juspay/neurolink 10.4.2 → 10.4.3

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

@@ -22,7 +22,7 @@ import { ProxyRuntimeConfigStore } from "../../lib/proxy/runtimeConfig.js";
  *   string) recorded when the supervisor we expect at `pid` was launched.
  *   When provided, this is cross-checked against `pid`'s actual OS-reported
  *   start time (see {@link getProcessStartTime}) — the args match alone
- *   ("neurolink" + "proxy" both present) is not airtight, since an
+ *   (the `neurolink proxy start` command is present) is not airtight, since an
  *   unrelated process (e.g. a shell running this very test suite, or a
  *   coincidentally-named script) could match it too. A pid recycled by such
  *   a process would have a start time far from the recorded supervisor

package/dist/cli/commands/proxy.js

@@ -187,7 +187,7 @@ async function getProcessStartTime(pid) {
  *   string) recorded when the supervisor we expect at `pid` was launched.
  *   When provided, this is cross-checked against `pid`'s actual OS-reported
  *   start time (see {@link getProcessStartTime}) — the args match alone
- *   ("neurolink" + "proxy" both present) is not airtight, since an
+ *   (the `neurolink proxy start` command is present) is not airtight, since an
  *   unrelated process (e.g. a shell running this very test suite, or a
  *   coincidentally-named script) could match it too. A pid recycled by such
  *   a process would have a start time far from the recorded supervisor
@@ -215,9 +215,9 @@ export async function processLooksLikeProxySupervisor(pid, expectedStartTimeIso)
     // "neurolink", an editor with a neurolink file open) would match, and a
     // stale/recycled pid running such a process could then be SIGTERM'd/
     // SIGKILL'd by `ensureSupervisorStoppedBeforeClear` during uninstall.
-    // Require the actual proxy-supervisor invocation — both "neurolink" AND
-    // the "proxy" subcommand present in args.
-    if (!(/neurolink/i.test(args) && /\bproxy\b/i.test(args))) {
+    // Require the actual proxy-supervisor invocation. Commands such as
+    // `neurolink proxy status` must never be mistaken for the listener owner.
+    if (!/\bneurolink(?:-proxy)?\b.*\bproxy\s+start\b/i.test(args)) {
         return false;
     }
     if (!expectedStartTimeIso) {
@@ -1556,6 +1556,80 @@ export async function createProxyStartApp(params) {
         });
         const primaryAccount = await resolveStatusPrimaryAccount(activeProxyConfig);
         const activeUpdaterPid = supervisorState?.updaterPid ?? runtimeState?.updaterPid;
+        const accountRows = Object.values(stats.accounts).map((account) => {
+            const normalizedKey = normalizeAnthropicAccountKey(account.label);
+            const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
+            const accountKey = storedAccountKeys.has(normalizedKey)
+                ? normalizedKey
+                : isLegacyAccount
+                    ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                    : account.label === "env"
+                        ? ENV_ANTHROPIC_ACCOUNT_KEY
+                        : normalizedKey;
+            const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
+            const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+            const accountStatus = disabledAccountKeys.has(accountKey)
+                ? "disabled"
+                : !isAccountAllowed(accountKey, activeAccountAllowlist)
+                    ? "excluded"
+                    : accountInventoryLoaded && account.type === "oauth" && !isStored
+                        ? "removed"
+                        : cooling
+                            ? "cooling"
+                            : "active";
+            return {
+                label: account.label,
+                type: account.type,
+                attempts: account.attemptCount,
+                requests: account.successCount + account.errorCount,
+                success: account.successCount,
+                errors: account.errorCount,
+                attemptErrors: account.attemptErrorCount,
+                rateLimits: account.rateLimitCount,
+                transientRateLimits: account.transientRateLimitCount,
+                quotaRateLimits: account.quotaRateLimitCount,
+                cooling,
+                status: accountStatus,
+            };
+        });
+        const attributed = accountRows.reduce((total, account) => ({
+            attempts: total.attempts + (account.attempts ?? 0),
+            requests: total.requests + (account.requests ?? 0),
+            success: total.success + (account.success ?? 0),
+            errors: total.errors + (account.errors ?? 0),
+            attemptErrors: total.attemptErrors + (account.attemptErrors ?? 0),
+            rateLimits: total.rateLimits + (account.rateLimits ?? 0),
+            transientRateLimits: total.transientRateLimits + (account.transientRateLimits ?? 0),
+            quotaRateLimits: total.quotaRateLimits + (account.quotaRateLimits ?? 0),
+        }), {
+            attempts: 0,
+            requests: 0,
+            success: 0,
+            errors: 0,
+            attemptErrors: 0,
+            rateLimits: 0,
+            transientRateLimits: 0,
+            quotaRateLimits: 0,
+        });
+        const unattributed = {
+            attempts: Math.max(0, stats.totalAttempts - attributed.attempts),
+            requests: Math.max(0, stats.totalRequests - attributed.requests),
+            success: Math.max(0, stats.totalSuccess - attributed.success),
+            errors: Math.max(0, stats.totalErrors - attributed.errors),
+            attemptErrors: Math.max(0, stats.totalAttemptErrors - attributed.attemptErrors),
+            rateLimits: Math.max(0, stats.totalRateLimits - attributed.rateLimits),
+            transientRateLimits: Math.max(0, stats.totalTransientRateLimits - attributed.transientRateLimits),
+            quotaRateLimits: Math.max(0, stats.totalQuotaRateLimits - attributed.quotaRateLimits),
+        };
+        if (Object.values(unattributed).some((count) => count > 0)) {
+            accountRows.push({
+                label: "unattributed",
+                type: "internal",
+                ...unattributed,
+                cooling: false,
+                status: "unattributed",
+            });
+        }
         return c.json({
             status: "running",
             ready: health.ready,
@@ -1578,42 +1652,7 @@ export async function createProxyStartApp(params) {
                 totalRateLimits: stats.totalRateLimits,
                 totalTransientRateLimits: stats.totalTransientRateLimits,
                 totalQuotaRateLimits: stats.totalQuotaRateLimits,
-                accounts: Object.values(stats.accounts).map((account) => {
-                    const normalizedKey = normalizeAnthropicAccountKey(account.label);
-                    const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
-                    const accountKey = storedAccountKeys.has(normalizedKey)
-                        ? normalizedKey
-                        : isLegacyAccount
-                            ? LEGACY_ANTHROPIC_ACCOUNT_KEY
-                            : account.label === "env"
-                                ? ENV_ANTHROPIC_ACCOUNT_KEY
-                                : normalizedKey;
-                    const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
-                    const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
-                    const accountStatus = disabledAccountKeys.has(accountKey)
-                        ? "disabled"
-                        : !isAccountAllowed(accountKey, activeAccountAllowlist)
-                            ? "excluded"
-                            : accountInventoryLoaded && account.type === "oauth" && !isStored
-                                ? "removed"
-                                : cooling
-                                    ? "cooling"
-                                    : "active";
-                    return {
-                        label: account.label,
-                        type: account.type,
-                        attempts: account.attemptCount,
-                        requests: account.successCount + account.errorCount,
-                        success: account.successCount,
-                        errors: account.errorCount,
-                        attemptErrors: account.attemptErrorCount,
-                        rateLimits: account.rateLimitCount,
-                        transientRateLimits: account.transientRateLimitCount,
-                        quotaRateLimits: account.quotaRateLimitCount,
-                        cooling,
-                        status: accountStatus,
-                    };
-                }),
+                accounts: accountRows,
                 primaryAccount,
                 persistence: getUsageStatsPersistenceStatus(),
             },
@@ -1930,9 +1969,11 @@ function registerProxyShutdownHandlers(params) {
             }
         }
         const usageStatsFlush = import("../../lib/proxy/usageStats.js").then(({ flushUsageStats }) => flushUsageStats());
-        const [usageStatsFlushResult, lifecycleFlushResult] = await Promise.allSettled([
+        const requestLogsFlush = import("../../lib/proxy/requestLogger.js").then(({ flushRequestLogs }) => flushRequestLogs());
+        const [usageStatsFlushResult, lifecycleFlushResult, requestLogsFlushResult,] = await Promise.allSettled([
             withTimeout(usageStatsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy usage statistics during shutdown"),
             withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown"),
+            withTimeout(requestLogsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy request logs during shutdown"),
         ]);
         if (usageStatsFlushResult.status === "rejected") {
             const error = usageStatsFlushResult.reason;
@@ -1942,6 +1983,10 @@ function registerProxyShutdownHandlers(params) {
             const error = lifecycleFlushResult.reason;
             logger.debug(`[proxy] lifecycle metadata flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
+        if (requestLogsFlushResult.status === "rejected") {
+            const error = requestLogsFlushResult.reason;
+            logger.warn(`[proxy] request log flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+        }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../lib/services/server/ai/observability/instrumentation.js");
             await flushOpenTelemetry();
@@ -2136,8 +2181,27 @@ async function startProxyRuntime(params) {
     let stopRuntimeConfig;
     if (params.runtimeConfigStore) {
         const runtimeConfigStore = params.runtimeConfigStore;
-        const unsubscribeReload = runtimeConfigStore.subscribeReload(() => {
-            persistRuntimeConfig(runtimeConfigStore.getSnapshot());
+        const unsubscribeReload = runtimeConfigStore.subscribeReload((result) => {
+            const snapshot = runtimeConfigStore.getSnapshot();
+            persistRuntimeConfig(snapshot);
+            if (socketWorker &&
+                result.applied &&
+                result.changed &&
+                result.environmentChanged &&
+                process.connected &&
+                process.send) {
+                try {
+                    process.send({
+                        type: "proxy-worker:replacement-requested",
+                        generation: getProxyWorkerGeneration(),
+                        pid: process.pid,
+                        reason: "environment",
+                    });
+                }
+                catch (error) {
+                    logger.warn(`[proxy] failed to request environment replacement: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
         });
         const reloadOnSighup = () => {
             void runtimeConfigStore.reload("sighup");
@@ -2646,20 +2710,23 @@ export const proxyStatusCommand = {
                             supervisorState.rolling.active?.pid === state?.pid)
                     : true);
             if ((state || supervisorState) && (servingWorker || supervisorRunning)) {
-                const activeHost = state?.host ?? supervisorState?.host ?? null;
-                const activePort = state?.port ?? supervisorState?.port ?? null;
+                const servingState = servingWorker ? state : null;
+                const activeHost = servingState?.host ?? supervisorState?.host ?? null;
+                const activePort = servingState?.port ?? supervisorState?.port ?? null;
                 status.running = true;
                 status.pid = servingWorker && state ? state.pid : null;
                 status.port = activePort;
                 status.host = activeHost;
-                status.mode = state
-                    ? state.passthrough
+                status.mode = servingState
+                    ? servingState.passthrough
                         ? "passthrough"
                         : "full"
                     : null;
-                status.strategy = state?.strategy ?? null;
+                status.strategy = servingState?.strategy ?? null;
                 status.startTime =
-                    state?.startTime ?? supervisorState?.startTime ?? null;
+                    (supervisorRunning ? supervisorState?.startTime : null) ??
+                        servingState?.startTime ??
+                        null;
                 status.uptime = status.startTime
                     ? Date.now() - new Date(status.startTime).getTime()
                     : null;
@@ -2667,17 +2734,18 @@ export const proxyStatusCommand = {
                     activeHost && activePort
                         ? `http://${activeHost === "0.0.0.0" ? "localhost" : activeHost}:${activePort}`
                         : null;
-                status.envFile = state?.envFile ?? null;
-                status.fallbackChain = state?.fallbackChain ?? null;
-                status.accountAllowlist = state?.accountAllowlist ?? null;
-                status.configGeneration = state?.configGeneration ?? null;
-                status.configLoadedAt = state?.configLoadedAt ?? null;
-                status.lastConfigReloadError = state?.lastConfigReloadError ?? null;
+                status.envFile = servingState?.envFile ?? null;
+                status.fallbackChain = servingState?.fallbackChain ?? null;
+                status.accountAllowlist = servingState?.accountAllowlist ?? null;
+                status.configGeneration = servingState?.configGeneration ?? null;
+                status.configLoadedAt = servingState?.configLoadedAt ?? null;
+                status.lastConfigReloadError =
+                    servingState?.lastConfigReloadError ?? null;
                 status.supervisorPid = supervisorPid ?? null;
                 status.supervisorRunning = supervisorRunning;
                 status.rolling = supervisorState?.rolling ?? null;
                 status.updaterPid =
-                    supervisorState?.updaterPid ?? state?.updaterPid ?? null;
+                    supervisorState?.updaterPid ?? servingState?.updaterPid ?? null;
                 status.updaterRunning = status.updaterPid
                     ? isProcessRunning(status.updaterPid)
                     : false;

package/dist/cli/commands/proxyAnalyze.js

@@ -11,7 +11,7 @@ function printAnalysis(report) {
     logger.always(chalk.gray("=".repeat(50)));
     logger.always(`  Since:       ${chalk.cyan(report.since)}`);
     logger.always(`  Logs:        ${chalk.cyan(report.logsDir)}`);
-    logger.always(`  Files:       ${report.files.requests} request, ${report.files.attempts} attempt, ${report.files.lifecycle} lifecycle`);
+    logger.always(`  Files:       ${report.files.requests} request, ${report.files.attempts} attempt, ${report.files.lifecycle} lifecycle, ${report.files.debug} debug`);
     logger.always("");
     logger.always(chalk.bold("  Reliability"));
     logger.always(report.coverage.finalRequests
@@ -68,6 +68,15 @@ function printAnalysis(report) {
     logger.always("");
     logger.always(chalk.bold("  Data Quality"));
     logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates`);
+    for (const [stream, range] of Object.entries(report.dataQuality.streams)) {
+        if (range.observedFrom) {
+            logger.always(`    ${stream}: ${range.observedFrom} to ${range.observedTo}${range.startsAtOrBeforeRequestedWindow ? "" : chalk.yellow(" (starts after requested window)")}`);
+        }
+    }
+    const artifacts = report.dataQuality.bodyArtifacts;
+    if (artifacts.capturesIndexed > 0) {
+        logger.always(`    Body artifacts: ${artifacts.artifactsPresent}/${artifacts.artifactsReferenced} present, ${artifacts.artifactsMissing} missing, ${artifacts.writeFailures} write failures, ${artifacts.invalidPaths} invalid paths, ${artifacts.truncatedCaptures} truncated captures`);
+    }
     if (report.accounts.length > 0) {
         logger.always("");
         logger.always(chalk.bold("  Accounts"));

package/dist/lib/proxy/proxyAnalysis.js

@@ -1,17 +1,41 @@
 import { createReadStream } from "node:fs";
-import { readdir } from "node:fs/promises";
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const DEBUG_FILE_PATTERN = /^proxy-debug-\d{4}-\d{2}-\d{2}\.jsonl$/;
+const ARTIFACT_STAT_CONCURRENCY = 64;
 const LIFECYCLE_EVENTS = new Set([
     "request_accepted",
     "response_headers",
     "response_first_chunk",
     "request_terminal",
 ]);
+function isContainedPath(root, candidate) {
+    const candidateRelative = relative(root, candidate);
+    return (candidateRelative.length > 0 &&
+        !isAbsolute(candidateRelative) &&
+        candidateRelative !== ".." &&
+        !candidateRelative.startsWith(`..${sep}`));
+}
+async function inspectBodyArtifact(artifactPath, canonicalBodiesRoot) {
+    if (!canonicalBodiesRoot) {
+        return "missing";
+    }
+    try {
+        const canonicalArtifactPath = await realpath(artifactPath);
+        if (!isContainedPath(canonicalBodiesRoot, canonicalArtifactPath)) {
+            return "invalid";
+        }
+        return (await stat(canonicalArtifactPath)).isFile() ? "present" : "missing";
+    }
+    catch {
+        return "missing";
+    }
+}
 function increment(counter, key) {
     counter[key] = (counter[key] ?? 0) + 1;
 }
@@ -192,6 +216,7 @@ async function discoverLogFiles(logsDir) {
         lifecycleFiles: matching(LIFECYCLE_FILE_PATTERN),
         requestFiles: matching(REQUEST_FILE_PATTERN),
         attemptFiles: matching(ATTEMPT_FILE_PATTERN),
+        debugFiles: matching(DEBUG_FILE_PATTERN),
     };
 }
 /** Analyze local proxy logs without reading request or response body artifacts. */
@@ -199,7 +224,24 @@ export async function analyzeProxyLogs(options) {
     const nowMs = options?.nowMs ?? Date.now();
     const sinceMs = parseSince(options?.since ?? "24h", nowMs);
     const logsDir = resolve(options?.logsDir ?? join(homedir(), ".neurolink", "logs"));
-    const { lifecycleFiles, requestFiles, attemptFiles } = await discoverLogFiles(logsDir);
+    const { lifecycleFiles, requestFiles, attemptFiles, debugFiles } = await discoverLogFiles(logsDir);
+    const observedRanges = {
+        lifecycle: { from: null, to: null },
+        requests: { from: null, to: null },
+        attempts: { from: null, to: null },
+        debug: { from: null, to: null },
+    };
+    const observeTimestamp = (stream, record) => {
+        const timestamp = Date.parse(String(record.timestamp ?? ""));
+        if (!Number.isFinite(timestamp)) {
+            return null;
+        }
+        const range = observedRanges[stream];
+        range.from =
+            range.from === null ? timestamp : Math.min(range.from, timestamp);
+        range.to = range.to === null ? timestamp : Math.max(range.to, timestamp);
+        return timestamp;
+    };
     let linesRead = 0;
     let malformedLines = 0;
     let unsupportedLifecycleLines = 0;
@@ -216,8 +258,8 @@ export async function analyzeProxyLogs(options) {
     const sequences = new Map();
     for (const filePath of lifecycleFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("lifecycle", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const event = stringValue(record.event);
@@ -298,8 +340,8 @@ export async function analyzeProxyLogs(options) {
     let unclassifiedRateLimits = 0;
     for (const filePath of attemptFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("attempts", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -360,8 +402,8 @@ export async function analyzeProxyLogs(options) {
     const terminalStreamErrors = new Set();
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
-            const timestamp = Date.parse(String(record.timestamp ?? ""));
-            if (!Number.isFinite(timestamp) || timestamp < sinceMs) {
+            const timestamp = observeTimestamp("requests", record);
+            if (timestamp === null || timestamp < sinceMs) {
                 return;
             }
             const requestId = stringValue(record.requestId);
@@ -391,6 +433,70 @@ export async function analyzeProxyLogs(options) {
             malformedLines += 1;
         });
     }
+    let capturesIndexed = 0;
+    let truncatedCaptures = 0;
+    let writeFailures = 0;
+    let invalidPaths = 0;
+    const referencedArtifacts = new Set();
+    const bodiesRoot = resolve(logsDir, "bodies");
+    for (const filePath of debugFiles) {
+        linesRead += await readJsonLines(filePath, (record) => {
+            const timestamp = observeTimestamp("debug", record);
+            if (timestamp === null || timestamp < sinceMs) {
+                return;
+            }
+            if (record.type !== "body_capture") {
+                return;
+            }
+            capturesIndexed += 1;
+            truncatedCaptures += record.bodyTruncated === true ? 1 : 0;
+            writeFailures += record.bodyWriteFailed === true ? 1 : 0;
+            const bodyPath = stringValue(record.bodyPath);
+            if (!bodyPath) {
+                return;
+            }
+            if (bodyPath.includes("\0") || bodyPath.split(/[\\/]/).includes("..")) {
+                invalidPaths += 1;
+                return;
+            }
+            const resolvedBodyPath = resolve(logsDir, bodyPath);
+            if (!isContainedPath(bodiesRoot, resolvedBodyPath)) {
+                invalidPaths += 1;
+                return;
+            }
+            referencedArtifacts.add(resolvedBodyPath);
+        }, () => {
+            malformedLines += 1;
+        });
+    }
+    const artifactPaths = [...referencedArtifacts];
+    let canonicalBodiesRoot = null;
+    let bodiesRootUnsafe = false;
+    try {
+        const bodiesRootStat = await lstat(bodiesRoot);
+        if (bodiesRootStat.isDirectory() && !bodiesRootStat.isSymbolicLink()) {
+            canonicalBodiesRoot = await realpath(bodiesRoot);
+        }
+        else {
+            bodiesRootUnsafe = true;
+        }
+    }
+    catch {
+        // A missing body directory means every lexically valid reference is absent.
+    }
+    let artifactsPresent = 0;
+    let artifactsMissing = 0;
+    for (let offset = 0; offset < artifactPaths.length; offset += ARTIFACT_STAT_CONCURRENCY) {
+        const presence = await Promise.all(artifactPaths
+            .slice(offset, offset + ARTIFACT_STAT_CONCURRENCY)
+            .map((artifactPath) => bodiesRootUnsafe
+            ? Promise.resolve("invalid")
+            : inspectBodyArtifact(artifactPath, canonicalBodiesRoot)));
+        artifactsPresent += presence.filter((value) => value === "present").length;
+        artifactsMissing += presence.filter((value) => value === "missing").length;
+        invalidPaths += presence.filter((value) => value === "invalid").length;
+    }
+    const artifactsReferenced = artifactsPresent + artifactsMissing;
     const finalSummary = summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts);
     return {
         generatedAt: new Date(nowMs).toISOString(),
@@ -400,11 +506,12 @@ export async function analyzeProxyLogs(options) {
             lifecycle: lifecycleFiles.length,
             requests: requestFiles.length,
             attempts: attemptFiles.length,
+            debug: debugFiles.length,
         },
         coverage: {
-            lifecycle: lifecycleFiles.length > 0,
-            finalRequests: requestFiles.length > 0,
-            attempts: attemptFiles.length > 0,
+            lifecycle: accepted.size + headers.size + firstChunks.size + terminal.size > 0,
+            finalRequests: finalRequests.size > 0 || terminalStreamErrors.size > 0,
+            attempts: totalAttempts > 0,
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
         },
@@ -414,6 +521,23 @@ export async function analyzeProxyLogs(options) {
             unsupportedLifecycleLines,
             lifecycleSequenceGaps,
             lifecycleSequenceDuplicates,
+            streams: Object.fromEntries(Object.entries(observedRanges).map(([stream, range]) => [
+                stream,
+                {
+                    observedFrom: range.from === null ? null : new Date(range.from).toISOString(),
+                    observedTo: range.to === null ? null : new Date(range.to).toISOString(),
+                    startsAtOrBeforeRequestedWindow: range.from !== null && range.from <= sinceMs,
+                },
+            ])),
+            bodyArtifacts: {
+                capturesIndexed,
+                artifactsReferenced,
+                artifactsPresent,
+                artifactsMissing,
+                invalidPaths,
+                writeFailures,
+                truncatedCaptures,
+            },
         },
         lifecycle: {
             accepted: accepted.size,

package/dist/lib/proxy/requestLogger.d.ts

@@ -6,6 +6,8 @@
  * Useful for debugging and auditing proxy traffic.
  */
 import type { ProxyBodyCaptureEntry, RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
+/** Wait, up to a bounded deadline, for admitted request/body writes to settle. */
+export declare function flushRequestLogs(timeoutMs?: number): Promise<void>;
 export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**