@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/proxy/logFinalizer.ts

@@ -1,777 +0,0 @@
-import { Buffer } from "node:buffer";
-import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Worker } from "node:worker_threads";
-import { writeChunks } from "./chunkStorage";
-import { formatForPath } from "./formats";
-import { appendLogEntry, logger } from "./logger";
-import type { RawStreamSource } from "./rawStreamCapture";
-import type { CapturedLog } from "./schemas";
-import {
-  getSessionProcess,
-  getSessionProcessPendingCount,
-  isSessionProcessAvailable,
-} from "./sessionProcess";
-import { persistFinalizedLogUpdate } from "./store";
-import { computeTokensPerSecond } from "./streamTiming";
-import { analyzeToolSchemaWarnings } from "./toolSchemaWarnings";
-import { isPlainRecord, safeGetOwnProperty } from "../lib/objectUtils";
-
-type BaseFinalizeLogJob = {
-  log: CapturedLog;
-  upstreamUrl: string;
-  elapsedMs: number;
-};
-
-export type FinalizeNonStreamingLogJob = BaseFinalizeLogJob & {
-  type: "non-streaming";
-  responseStatus: number;
-  responseBody: string;
-};
-
-export type FinalizeStreamingLogJob = BaseFinalizeLogJob & {
-  type: "streaming";
-  responseStatus: number;
-  rawStream: string | RawStreamSource;
-  collectStreamingChunks: boolean;
-  firstChunkMs: number | null;
-  totalStreamMs: number;
-  terminalError?: string | null;
-};
-
-export type FinalizeStreamAbortLogJob = BaseFinalizeLogJob & {
-  type: "stream-abort";
-  rawStream: string | RawStreamSource;
-  hasChunks: boolean;
-  collectStreamingChunks: boolean;
-  firstChunkMs: number | null;
-  totalStreamMs: number;
-};
-
-export type FinalizeLogJob =
-  | FinalizeNonStreamingLogJob
-  | FinalizeStreamingLogJob
-  | FinalizeStreamAbortLogJob;
-
-export type FinalizeLogResult = {
-  log: CapturedLog;
-  upstreamUrl: string;
-  error: string | null;
-  cleanupRawStreamPath?: string | null;
-};
-
-const DEFAULT_MAX_FINALIZE_STREAM_BYTES = 20 * 1024 * 1024;
-const DEFAULT_FINALIZE_JOB_TIMEOUT_MS = 15_000;
-
-function resolveMaxFinalizeStreamBytes(): number {
-  const raw = process.env["AGENT_INSPECTOR_MAX_FINALIZE_STREAM_BYTES"];
-  if (raw === undefined || raw === "") return DEFAULT_MAX_FINALIZE_STREAM_BYTES;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_MAX_FINALIZE_STREAM_BYTES;
-  return Math.floor(parsed);
-}
-
-function resolveFinalizeJobTimeoutMs(): number {
-  const raw = process.env["AGENT_INSPECTOR_FINALIZE_JOB_TIMEOUT_MS"];
-  if (raw === undefined || raw === "") return DEFAULT_FINALIZE_JOB_TIMEOUT_MS;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed < 100) return DEFAULT_FINALIZE_JOB_TIMEOUT_MS;
-  return Math.floor(parsed);
-}
-
-export function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string, unknown> {
-  return {
-    timestamp: log.timestamp,
-    id: log.id,
-    method: log.method,
-    path: log.path,
-    model: log.model,
-    sessionId: log.sessionId,
-    rawRequestBody: log.rawRequestBody,
-    responseStatus: log.responseStatus,
-    responseText: log.responseText,
-    inputTokens: log.inputTokens,
-    outputTokens: log.outputTokens,
-    cacheCreationInputTokens: log.cacheCreationInputTokens,
-    cacheReadInputTokens: log.cacheReadInputTokens,
-    elapsedMs: log.elapsedMs,
-    firstChunkMs: log.firstChunkMs,
-    totalStreamMs: log.totalStreamMs,
-    tokensPerSecond: log.tokensPerSecond,
-    streaming: log.streaming,
-    userAgent: log.userAgent,
-    origin: log.origin,
-    upstreamUrl,
-    clientPort: log.clientPort,
-    clientPid: log.clientPid,
-    clientCwd: log.clientCwd,
-    clientProjectFolder: log.clientProjectFolder,
-    streamingChunks: log.streamingChunks,
-    streamingChunksPath: log.streamingChunksPath,
-    captureIncomplete: log.captureIncomplete ?? false,
-    droppedChunks: log.droppedChunks ?? 0,
-    droppedBytes: log.droppedBytes ?? 0,
-    captureIncompleteReason: log.captureIncompleteReason ?? null,
-    warnings: log.warnings,
-    error: log.error,
-  };
-}
-
-function cloneLog(log: CapturedLog): CapturedLog {
-  return { ...log };
-}
-
-function errorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}
-
-function persistStreamingChunks(log: CapturedLog): void {
-  if (log.streamingChunks !== undefined && log.streamingChunks.chunks.length > 0) {
-    const chunkPath = writeChunks(
-      log.id,
-      log.streamingChunks.chunks,
-      log.streamingChunks.truncated,
-    );
-    log.streamingChunksPath = chunkPath;
-  }
-}
-
-function finalizeWithError(
-  job: FinalizeLogJob,
-  log: CapturedLog,
-  fallbackStatus: number,
-  fallbackResponseText: string,
-  err: unknown,
-  cleanupRawStreamPath: string | null = null,
-): FinalizeLogResult {
-  const message = errorMessage(err);
-  logger.error(`[logFinalizer] Failed to finalize log #${log.id}:`, message);
-  log.responseStatus = log.responseStatus ?? fallbackStatus;
-  log.responseText = log.responseText ?? fallbackResponseText;
-  log.elapsedMs = job.elapsedMs;
-  applyOptionalStreamingTiming(log, job);
-  log.error = message;
-  return { log, upstreamUrl: job.upstreamUrl, error: message, cleanupRawStreamPath };
-}
-
-function applyOptionalStreamingTiming(log: CapturedLog, job: FinalizeLogJob): void {
-  switch (job.type) {
-    case "non-streaming":
-      log.firstChunkMs = null;
-      log.totalStreamMs = null;
-      log.tokensPerSecond = null;
-      return;
-    case "streaming":
-    case "stream-abort":
-      log.firstChunkMs = job.firstChunkMs;
-      log.totalStreamMs = job.totalStreamMs;
-      log.tokensPerSecond = computeTokensPerSecond({
-        outputTokens: log.outputTokens,
-        firstChunkMs: job.firstChunkMs,
-        totalStreamMs: job.totalStreamMs,
-      });
-      return;
-    default: {
-      const _exhaustive: never = job;
-      logger.error(`[logFinalizer] Unhandled job type: ${JSON.stringify(_exhaustive)}`);
-      return;
-    }
-  }
-}
-
-type ToolSchemaWarningAnalysisJob = {
-  log: CapturedLog;
-  upstreamUrl: string;
-  error: string | null;
-};
-
-let toolSchemaWarningQueue: Promise<void> = Promise.resolve();
-
-function deferToolSchemaWarningAnalysis(): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, 0);
-  });
-}
-
-function withToolSchemaWarnings(log: CapturedLog): CapturedLog | null {
-  const warnings = analyzeToolSchemaWarnings({
-    rawRequestBody: log.rawRequestBody,
-    responseText: log.responseText,
-    apiFormat: log.apiFormat,
-  });
-  if (warnings.length === 0) return null;
-  const mergedWarnings = Array.from(new Set([...(log.warnings ?? []), ...warnings]));
-  if (mergedWarnings.length === (log.warnings?.length ?? 0)) return null;
-  return { ...log, warnings: mergedWarnings };
-}
-
-async function runToolSchemaWarningAnalysis(job: ToolSchemaWarningAnalysisJob): Promise<void> {
-  await deferToolSchemaWarningAnalysis();
-  const updatedLog = withToolSchemaWarnings(job.log);
-  if (updatedLog === null) return;
-
-  appendLogEntry({ ...buildFileLogEntry(updatedLog, job.upstreamUrl), error: job.error });
-  await persistFinalizedLogUpdate(updatedLog);
-}
-
-function scheduleToolSchemaWarningAnalysis(job: ToolSchemaWarningAnalysisJob): void {
-  toolSchemaWarningQueue = toolSchemaWarningQueue
-    .catch(() => undefined)
-    .then(() => runToolSchemaWarningAnalysis(job))
-    .catch((err: unknown) => {
-      logger.warn(
-        `[logFinalizer] Tool schema warning analysis failed for log #${job.log.id}:`,
-        errorMessage(err),
-      );
-    });
-}
-
-export async function flushToolSchemaWarningAnalysis(): Promise<void> {
-  await toolSchemaWarningQueue;
-}
-
-function finalizeNonStreaming(
-  job: FinalizeNonStreamingLogJob,
-  log: CapturedLog,
-): FinalizeLogResult {
-  const formatHandler = formatForPath(log.path);
-  if (formatHandler === null) {
-    return finalizeWithError(job, log, job.responseStatus, job.responseBody, "Unsupported format");
-  }
-
-  try {
-    const tokens = formatHandler.extractTokens(job.responseBody);
-
-    log.elapsedMs = job.elapsedMs;
-    log.firstChunkMs = null;
-    log.totalStreamMs = null;
-    log.tokensPerSecond = null;
-    log.responseStatus = job.responseStatus;
-    log.responseText = job.responseBody;
-    log.inputTokens = tokens.inputTokens;
-    log.outputTokens = tokens.outputTokens;
-    log.cacheCreationInputTokens = tokens.cacheCreationInputTokens;
-    log.cacheReadInputTokens = tokens.cacheReadInputTokens;
-
-    return { log, upstreamUrl: job.upstreamUrl, error: null };
-  } catch (err) {
-    return finalizeWithError(job, log, job.responseStatus, job.responseBody, err);
-  }
-}
-
-function cleanupPathForRawStream(rawStream: string | RawStreamSource): string | null {
-  if (typeof rawStream === "string") return null;
-  switch (rawStream.type) {
-    case "memory":
-      return null;
-    case "file":
-      return rawStream.path;
-    default: {
-      const _exhaustive: never = rawStream;
-      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
-      return null;
-    }
-  }
-}
-
-type OversizedRawStream = {
-  byteLength: number;
-  limit: number;
-};
-
-function rawStreamByteLength(rawStream: string | RawStreamSource): number | null {
-  if (typeof rawStream === "string") {
-    return Buffer.byteLength(rawStream, "utf8");
-  }
-
-  switch (rawStream.type) {
-    case "memory":
-      return Buffer.byteLength(rawStream.rawStream, "utf8");
-    case "file":
-      try {
-        return statSync(rawStream.path).size;
-      } catch {
-        return null;
-      }
-    default: {
-      const _exhaustive: never = rawStream;
-      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
-      return null;
-    }
-  }
-}
-
-function getOversizedRawStream(rawStream: string | RawStreamSource): OversizedRawStream | null {
-  const limit = resolveMaxFinalizeStreamBytes();
-  const byteLength = rawStreamByteLength(rawStream);
-  if (byteLength === null || byteLength <= limit) return null;
-  return { byteLength, limit };
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes} bytes`;
-  if (bytes < 1024 * 1024) return `${Math.ceil(bytes / 1024)} KB`;
-  return `${Math.ceil(bytes / (1024 * 1024))} MB`;
-}
-
-function oversizedRawStreamText(oversized: OversizedRawStream): string {
-  return (
-    `Streaming response omitted because the captured raw stream is ${formatBytes(
-      oversized.byteLength,
-    )}, exceeding the finalize limit of ${formatBytes(oversized.limit)}. ` +
-    "Increase AGENT_INSPECTOR_MAX_FINALIZE_STREAM_BYTES if this response must be parsed."
-  );
-}
-
-function readRawStream(rawStream: string | RawStreamSource): {
-  rawStreamText: string;
-  cleanupRawStreamPath: string | null;
-} {
-  if (typeof rawStream === "string") {
-    return { rawStreamText: rawStream, cleanupRawStreamPath: null };
-  }
-
-  switch (rawStream.type) {
-    case "memory":
-      return { rawStreamText: rawStream.rawStream, cleanupRawStreamPath: null };
-    case "file":
-      return {
-        rawStreamText: readFileSync(rawStream.path, "utf-8"),
-        cleanupRawStreamPath: rawStream.path,
-      };
-    default: {
-      const _exhaustive: never = rawStream;
-      logger.error(`[logFinalizer] Unhandled raw stream type: ${JSON.stringify(_exhaustive)}`);
-      return { rawStreamText: "", cleanupRawStreamPath: null };
-    }
-  }
-}
-
-function finalizeStreaming(job: FinalizeStreamingLogJob, log: CapturedLog): FinalizeLogResult {
-  const formatHandler = formatForPath(log.path);
-  if (formatHandler === null) {
-    return finalizeWithError(
-      job,
-      log,
-      job.responseStatus,
-      "Streaming response unavailable",
-      "Unsupported format",
-      cleanupPathForRawStream(job.rawStream),
-    );
-  }
-
-  const oversized = getOversizedRawStream(job.rawStream);
-  if (oversized !== null) {
-    log.elapsedMs = job.elapsedMs;
-    applyOptionalStreamingTiming(log, job);
-    log.responseStatus = job.responseStatus;
-    log.responseText = oversizedRawStreamText(oversized);
-    return {
-      log,
-      upstreamUrl: job.upstreamUrl,
-      error: null,
-      cleanupRawStreamPath: cleanupPathForRawStream(job.rawStream),
-    };
-  }
-
-  let rawStreamText = "";
-  let cleanupRawStreamPath: string | null = null;
-  try {
-    const raw = readRawStream(job.rawStream);
-    rawStreamText = raw.rawStreamText;
-    cleanupRawStreamPath = raw.cleanupRawStreamPath;
-    log.elapsedMs = job.elapsedMs;
-    log.responseStatus = job.responseStatus;
-    log.responseText = formatHandler.extractStream(
-      rawStreamText,
-      log,
-      log.model ?? undefined,
-      job.collectStreamingChunks,
-    );
-    applyOptionalStreamingTiming(log, job);
-    persistStreamingChunks(log);
-
-    return { log, upstreamUrl: job.upstreamUrl, error: null, cleanupRawStreamPath };
-  } catch (err) {
-    return finalizeWithError(
-      job,
-      log,
-      job.responseStatus,
-      rawStreamText === "" ? "Streaming response unavailable" : rawStreamText,
-      err,
-      cleanupRawStreamPath ?? cleanupPathForRawStream(job.rawStream),
-    );
-  }
-}
-
-function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog): FinalizeLogResult {
-  const formatHandler = formatForPath(log.path);
-  if (formatHandler === null && job.hasChunks) {
-    return finalizeWithError(
-      job,
-      log,
-      499,
-      "Client aborted",
-      "Unsupported format",
-      cleanupPathForRawStream(job.rawStream),
-    );
-  }
-
-  let rawStreamText = "";
-  let cleanupRawStreamPath: string | null = null;
-  try {
-    log.elapsedMs = job.elapsedMs;
-    applyOptionalStreamingTiming(log, job);
-    if (job.hasChunks && formatHandler !== null) {
-      const oversized = getOversizedRawStream(job.rawStream);
-      if (oversized !== null) {
-        log.responseText = `Client aborted. ${oversizedRawStreamText(oversized)}`;
-        return {
-          log,
-          upstreamUrl: job.upstreamUrl,
-          error: "Client aborted",
-          cleanupRawStreamPath: cleanupPathForRawStream(job.rawStream),
-        };
-      }
-      const raw = readRawStream(job.rawStream);
-      rawStreamText = raw.rawStreamText;
-      cleanupRawStreamPath = raw.cleanupRawStreamPath;
-      log.responseText = formatHandler.extractStream(
-        rawStreamText,
-        log,
-        log.model ?? undefined,
-        job.collectStreamingChunks,
-      );
-      applyOptionalStreamingTiming(log, job);
-      persistStreamingChunks(log);
-    } else {
-      log.responseText = "Client aborted";
-    }
-
-    return { log, upstreamUrl: job.upstreamUrl, error: "Client aborted", cleanupRawStreamPath };
-  } catch (err) {
-    return finalizeWithError(
-      job,
-      log,
-      499,
-      rawStreamText === "" ? "Client aborted" : rawStreamText,
-      err,
-      cleanupRawStreamPath ?? cleanupPathForRawStream(job.rawStream),
-    );
-  }
-}
-
-export function buildFinalizeLogResult(job: FinalizeLogJob): FinalizeLogResult {
-  const log = cloneLog(job.log);
-  const upstreamUrl = job.upstreamUrl;
-
-  switch (job.type) {
-    case "non-streaming":
-      return finalizeNonStreaming(job, log);
-    case "streaming": {
-      const result = finalizeStreaming(job, log);
-      if (job.terminalError !== undefined && job.terminalError !== null) {
-        result.log.error = job.terminalError;
-      }
-      return result;
-    }
-    case "stream-abort":
-      return finalizeStreamAbort(job, log);
-    default: {
-      const _exhaustive: never = job;
-      logger.error(`[logFinalizer] Unhandled job type: ${JSON.stringify(_exhaustive)}`);
-      return {
-        log,
-        upstreamUrl,
-        error: "Unhandled job type",
-        cleanupRawStreamPath: null,
-      };
-    }
-  }
-}
-
-export function buildFinalizeTimeoutResult(
-  job: FinalizeLogJob,
-  timeoutMs: number,
-): FinalizeLogResult {
-  const log = cloneLog(job.log);
-  const message = `Log finalization timed out after ${String(timeoutMs)}ms`;
-  log.elapsedMs = job.elapsedMs;
-  applyOptionalStreamingTiming(log, job);
-  let fallbackStatus = 499;
-  let cleanupRawStreamPath: string | null = null;
-  switch (job.type) {
-    case "non-streaming":
-    case "streaming":
-      fallbackStatus = job.responseStatus;
-      cleanupRawStreamPath =
-        job.type === "streaming" ? cleanupPathForRawStream(job.rawStream) : null;
-      break;
-    case "stream-abort":
-      cleanupRawStreamPath = cleanupPathForRawStream(job.rawStream);
-      break;
-    default: {
-      const _exhaustive: never = job;
-      logger.error(`[logFinalizer] Unhandled timeout job type: ${JSON.stringify(_exhaustive)}`);
-    }
-  }
-  log.responseStatus = log.responseStatus ?? fallbackStatus;
-  log.responseText = log.responseText ?? message;
-  log.captureIncomplete = true;
-  log.captureIncompleteReason = "finalize-timeout";
-  log.error = message;
-  return {
-    log,
-    upstreamUrl: job.upstreamUrl,
-    error: message,
-    cleanupRawStreamPath,
-  };
-}
-
-export async function commitFinalizeLogResult(result: FinalizeLogResult): Promise<void> {
-  const persistedError =
-    result.log.captureIncompleteReason === "upstream-stream-error"
-      ? (result.log.error ?? result.error ?? null)
-      : (result.error ?? result.log.error ?? null);
-  result.log.error = persistedError;
-  appendLogEntry({ ...buildFileLogEntry(result.log, result.upstreamUrl), error: persistedError });
-  await persistFinalizedLogUpdate(result.log);
-  scheduleToolSchemaWarningAnalysis({
-    log: cloneLog(result.log),
-    upstreamUrl: result.upstreamUrl,
-    error: persistedError,
-  });
-  if (result.cleanupRawStreamPath !== undefined && result.cleanupRawStreamPath !== null) {
-    try {
-      rmSync(result.cleanupRawStreamPath, { force: true });
-    } catch (err) {
-      logger.warn(
-        "[logFinalizer] Failed to remove raw stream temp file:",
-        result.cleanupRawStreamPath,
-        errorMessage(err),
-      );
-    }
-  }
-}
-
-// ── Worker pool ────────────────────────────────────────────────
-// buildFinalizeLogResult is the CPU-heavy step (token extraction,
-// SSE parsing, chunk persistence).  We offload it to a fixed pool
-// of Worker Threads so the main thread stays responsive even under
-// concurrent sessions.  commitFinalizeLogResult stays in-process
-// because it touches the in-memory cache, SSE emitter, and
-// append‑only log — all of which belong to the main thread.
-
-// ── Routing ─────────────────────────────────────────────────────
-// FINALIZER_RUNTIME selects the execution backend:
-//   "process" → per-session child process (max isolation)
-//   "worker"  → shared Worker Thread pool
-//   "inline"  → synchronous in-process (debug / fallback)
-// The default is the bounded shared Worker pool when its entry exists. The
-// per-session process backend remains an explicit isolation option only.
-// For backward compatibility, FINALIZER_USE_WORKER=0 forces "inline".
-
-const RUNTIME: "process" | "worker" | "inline" = (() => {
-  if (process.env["FINALIZER_USE_WORKER"] === "0") return "inline";
-  const mode = process.env["FINALIZER_RUNTIME"];
-  if (mode === "process") return "process";
-  if (mode === "worker") return "worker";
-  if (mode === "inline") return "inline";
-  if (isLogFinalizerWorkerAvailable()) return "worker";
-  return isSessionProcessAvailable() ? "process" : "inline";
-})();
-
-function executeBuildInSessionProcess(job: FinalizeLogJob): Promise<FinalizeLogResult> {
-  const sessionId = job.log.sessionId ?? "__unassigned__";
-  return getSessionProcess(sessionId)
-    .enqueue(job)
-    .catch((err: unknown) => {
-      const message = err instanceof Error ? err.message : String(err);
-      logger.error(
-        `[logFinalizer] Session process failed for log #${job.log.id}, ` +
-          `falling back to in-process: ${message}`,
-      );
-      return buildFinalizeLogResult(job);
-    });
-}
-
-function resolveBuildPromise(job: FinalizeLogJob): Promise<FinalizeLogResult> {
-  switch (RUNTIME) {
-    case "process":
-      return executeBuildInSessionProcess(job);
-    case "worker":
-      return executeBuildInWorker(job);
-    case "inline":
-      return Promise.resolve(buildFinalizeLogResult(job));
-    default: {
-      const _exhaustive: never = RUNTIME;
-      logger.error(`[logFinalizer] Unhandled runtime: ${JSON.stringify(_exhaustive)}`);
-      return Promise.resolve({
-        log: job.log,
-        upstreamUrl: job.upstreamUrl,
-        error: "Unhandled runtime",
-        cleanupRawStreamPath: null,
-      });
-    }
-  }
-}
-
-const WORKER_COUNT = Math.max(1, Number(process.env["FINALIZER_WORKER_COUNT"]) || 4);
-let _workers: Worker[] | null = null;
-const _pending = new Map<
-  string,
-  { resolve: (result: FinalizeLogResult) => void; reject: (err: Error) => void }
->();
-let _nextWorker = 0;
-let _jobSeq = 0;
-
-function resolveLogFinalizerWorkerUrl(): URL {
-  const workerDir = process.env["AGENT_INSPECTOR_WORKER_DIR"];
-  if (workerDir !== undefined && workerDir.trim().length > 0) {
-    const builtWorkerPath = join(workerDir, "logFinalizer.worker.js");
-    if (existsSync(builtWorkerPath)) return pathToFileURL(builtWorkerPath);
-  }
-  return new URL("./logFinalizer.worker.ts", import.meta.url);
-}
-
-export function isLogFinalizerWorkerAvailable(): boolean {
-  return existsSync(fileURLToPath(resolveLogFinalizerWorkerUrl()));
-}
-
-export type FinalizerRuntimeHealth = {
-  runtime: "process" | "worker" | "inline";
-  artifactAvailable: boolean;
-  activeWorkers: number | null;
-  configuredWorkers: number;
-  pendingJobs: number;
-};
-
-/** Safe aggregate state used by readiness checks; it contains no job or session data. */
-export function getFinalizerRuntimeHealth(): FinalizerRuntimeHealth {
-  const artifactAvailable =
-    RUNTIME === "worker"
-      ? isLogFinalizerWorkerAvailable()
-      : RUNTIME === "process"
-        ? isSessionProcessAvailable()
-        : isLogFinalizerWorkerAvailable() || isSessionProcessAvailable();
-  const activeWorkers =
-    _workers === null ? null : _workers.filter((worker) => worker.threadId > 0).length;
-  return {
-    runtime: RUNTIME,
-    artifactAvailable,
-    activeWorkers,
-    configuredWorkers: WORKER_COUNT,
-    pendingJobs: RUNTIME === "process" ? getSessionProcessPendingCount() : _pending.size,
-  };
-}
-
-function getWorkers(): Worker[] {
-  if (_workers !== null) return _workers;
-  _workers = [];
-  for (let i = 0; i < WORKER_COUNT; i++) {
-    const w = new Worker(resolveLogFinalizerWorkerUrl());
-    w.on("message", (raw: unknown) => {
-      if (!isPlainRecord(raw)) {
-        logger.error("[logFinalizer] Received malformed IPC message from worker, discarding");
-        return;
-      }
-      const id = safeGetOwnProperty(raw, "id");
-      const result = safeGetOwnProperty(raw, "result");
-      if (typeof id !== "string" || !isPlainRecord(result)) {
-        logger.error("[logFinalizer] Received malformed IPC message from worker, discarding");
-        return;
-      }
-      // Runtime shape validated above; the cast bridges unknown → FinalizeLogResult.
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const msg = { id, result: result as FinalizeLogResult };
-      const entry = _pending.get(msg.id);
-      if (entry !== undefined) {
-        _pending.delete(msg.id);
-        entry.resolve(msg.result);
-      }
-    });
-    w.on("error", (err) => {
-      logger.error(
-        "[logFinalizer] Worker error:",
-        err instanceof Error ? err.message : String(err),
-      );
-      // Reject all pending jobs for this worker so callers don't hang forever
-      for (const [id, entry] of _pending) {
-        _pending.delete(id);
-        entry.reject(
-          new Error(`Worker crashed: ${err instanceof Error ? err.message : String(err)}`),
-        );
-      }
-    });
-    _workers.push(w);
-  }
-  return _workers;
-}
-
-export function executeBuildInWorker(job: FinalizeLogJob): Promise<FinalizeLogResult> {
-  return new Promise((resolve, reject) => {
-    const list = getWorkers();
-    // getWorkers() always returns at least 1 worker; the array index is safe
-    const idx = _nextWorker % list.length;
-    _nextWorker++;
-    const w = list[idx];
-    if (w === undefined) {
-      reject(new Error("No workers available"));
-      return;
-    }
-    const id = String(++_jobSeq);
-    _pending.set(id, { resolve, reject });
-    w.postMessage({ id, job });
-  });
-}
-
-export function executeFinalizeLogJob(job: FinalizeLogJob): Promise<void> {
-  const timeoutMs = resolveFinalizeJobTimeoutMs();
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  const buildPromise = resolveBuildPromise(job);
-  const timeoutPromise = new Promise<FinalizeLogResult>((resolve) => {
-    timeout = setTimeout(() => {
-      logger.error(
-        `[logFinalizer] Finalize job timed out for log #${job.log.id} after ${String(timeoutMs)}ms`,
-      );
-      resolve(buildFinalizeTimeoutResult(job, timeoutMs));
-    }, timeoutMs);
-  });
-  void buildPromise.catch((err: unknown) => {
-    logger.error(
-      `[logFinalizer] Late finalize build failure for log #${job.log.id}:`,
-      errorMessage(err),
-    );
-  });
-
-  return Promise.race([buildPromise, timeoutPromise]).then(async (result) => {
-    if (timeout !== null) clearTimeout(timeout);
-    await commitFinalizeLogResult(result);
-    if (result.error !== null && result.error !== "Client aborted") {
-      return Promise.reject(new Error(result.error));
-    }
-    return undefined;
-  });
-}
-
-function detachLogFinalizerWorkers(): Worker[] {
-  const workers = _workers ?? [];
-  _workers = null;
-  for (const [id, entry] of _pending) {
-    _pending.delete(id);
-    entry.reject(new Error("Log finalizer worker pool is shutting down"));
-  }
-  return workers;
-}
-
-/** Close the shared worker pool after queued session tasks have drained. */
-export async function closeLogFinalizerWorkers(): Promise<void> {
-  const workers = detachLogFinalizerWorkers();
-  await Promise.all(workers.map((worker) => worker.terminate()));
-}
-
-/** Best-effort immediate worker teardown used when the shutdown deadline expires. */
-export function forceCloseLogFinalizerWorkers(): void {
-  for (const worker of detachLogFinalizerWorkers()) void worker.terminate();
-}