codesesh 1.0.4 → 1.0.6

package/dist/chunk-4QFNZCBR.js

@@ -0,0 +1,1271 @@
+#!/usr/bin/env node
+import {
+  AGENT_CATALOG,
+  PRIVATE_DIR_MODE,
+  PRIVATE_FILE_MODE,
+  WORKER_LOG_MESSAGE_TYPE,
+  isWorkerLogMessage,
+  setCoreDiagnostics
+} from "./chunk-4ND6AT6W.js";
+
+// src/logging.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes, randomUUID } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { getEnvironmentData, setEnvironmentData } from "worker_threads";
+
+// src/log-file-writer.ts
+import { appendFileSync, chmodSync, mkdirSync } from "fs";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  rename,
+  unlink
+} from "fs/promises";
+import { join } from "path";
+var MAX_BATCH_BYTES = 64 * 1024;
+var UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var CURRENT_LOG_PATTERN = new RegExp(`^codesesh-(\\d+)-${UUID_PATTERN}-active\\.log$`);
+var EMERGENCY_LOG_PATTERN = new RegExp(`^codesesh-(\\d+)-${UUID_PATTERN}-emergency\\.log$`);
+var RUN_LOG_PATTERN = new RegExp(`^codesesh-\\d+-${UUID_PATTERN}-\\d+\\.log$`);
+var LEGACY_ACTIVE_LOG_PATTERN = /^codesesh-(\d+)\.log$/;
+var LEGACY_ROTATED_LOG_PATTERN = /^codesesh-\d+-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z-\d+\.log$/;
+var ORIGINAL_ROTATED_LOG_PATTERN = /^codesesh-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z-\d+-\d+\.log$/;
+var ORIGINAL_ACTIVE_LOG_PATTERN = /^codesesh\.log$/;
+var LOG_LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function emptyDropCounts() {
+  return { debug: 0, info: 0, warn: 0, error: 0 };
+}
+function droppedCount(counts) {
+  return counts.debug + counts.info + counts.warn + counts.error;
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function isProcessAlive(pid) {
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) !== "ESRCH";
+  }
+}
+function activeLogPid(name) {
+  const match = CURRENT_LOG_PATTERN.exec(name) ?? EMERGENCY_LOG_PATTERN.exec(name) ?? LEGACY_ACTIVE_LOG_PATTERN.exec(name);
+  if (!match) return null;
+  const pid = Number(match[1]);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function isManagedLog(name) {
+  return CURRENT_LOG_PATTERN.test(name) || EMERGENCY_LOG_PATTERN.test(name) || RUN_LOG_PATTERN.test(name) || LEGACY_ACTIVE_LOG_PATTERN.test(name) || LEGACY_ROTATED_LOG_PATTERN.test(name) || ORIGINAL_ROTATED_LOG_PATTERN.test(name) || ORIGINAL_ACTIVE_LOG_PATTERN.test(name);
+}
+var AsyncLogFileWriter = class {
+  logDir;
+  prefix;
+  currentPath;
+  emergencyPath;
+  maxFileBytes;
+  maxFiles;
+  maxDirectoryBytes;
+  maxAgeMs;
+  maxQueueBytes;
+  createDropSummary;
+  queue = [];
+  inFlight = [];
+  dropped = emptyDropCounts();
+  queuedBytes = 0;
+  currentBytes = 0;
+  rotationIndex = 0;
+  handle = null;
+  drainPromise = null;
+  closePromise = null;
+  storagePrepared = false;
+  currentFileCreated = false;
+  needsRecoverySeparator = false;
+  writeFailureReported = false;
+  overflowReported = false;
+  closedWriteReported = false;
+  constructor(options) {
+    this.logDir = options.logDir;
+    this.prefix = `codesesh-${process.pid}-${options.runId}`;
+    this.currentPath = join(this.logDir, `${this.prefix}-active.log`);
+    this.emergencyPath = join(this.logDir, `${this.prefix}-emergency.log`);
+    this.maxFileBytes = options.maxFileBytes;
+    this.maxFiles = options.maxFiles;
+    this.maxDirectoryBytes = options.maxDirectoryBytes;
+    this.maxAgeMs = options.maxAgeMs;
+    this.maxQueueBytes = options.maxQueueBytes;
+    this.createDropSummary = options.createDropSummary;
+  }
+  get path() {
+    return this.currentPath;
+  }
+  enqueue(entry) {
+    if (this.closePromise) {
+      if (!this.closedWriteReported) {
+        this.closedWriteReported = true;
+        this.writeStderr("Log entry dropped after logger close");
+      }
+      return;
+    }
+    if (!this.makeRoom(entry)) {
+      this.recordDrop(entry.level);
+      this.scheduleDrain();
+      return;
+    }
+    this.queue.push(entry);
+    this.queuedBytes += entry.bytes;
+    this.scheduleDrain();
+  }
+  async flush() {
+    while (this.queue.length > 0 || droppedCount(this.dropped) > 0 || this.drainPromise) {
+      this.scheduleDrain();
+      const drain = this.drainPromise;
+      if (!drain) break;
+      await drain;
+    }
+  }
+  close() {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.finishClose();
+    return this.closePromise;
+  }
+  flushSync() {
+    const pending = this.queue.splice(0);
+    const pendingBytes = pending.reduce((total, entry) => total + entry.bytes, 0);
+    this.queuedBytes = Math.max(0, this.queuedBytes - pendingBytes);
+    const dropped = droppedCount(this.dropped);
+    const emergency = [...this.inFlight, ...pending];
+    if (dropped > 0) {
+      emergency.push(this.createDropSummary({ ...this.dropped }));
+      this.dropped = emptyDropCounts();
+    }
+    if (emergency.length === 0) return;
+    try {
+      mkdirSync(this.logDir, { recursive: true, mode: PRIVATE_DIR_MODE });
+      if (process.platform !== "win32") chmodSync(this.logDir, PRIVATE_DIR_MODE);
+      appendFileSync(this.emergencyPath, emergency.map((entry) => entry.line).join(""), {
+        encoding: "utf8",
+        mode: PRIVATE_FILE_MODE
+      });
+      if (process.platform !== "win32") chmodSync(this.emergencyPath, PRIVATE_FILE_MODE);
+    } catch (error) {
+      this.reportWriteFailure(error);
+    }
+  }
+  makeRoom(entry) {
+    if (entry.bytes > this.maxQueueBytes) return false;
+    if (entry.bytes <= this.maxQueueBytes - this.queuedBytes) return true;
+    if (entry.level === "debug" || entry.level === "info") return false;
+    const requiredBytes = entry.bytes - (this.maxQueueBytes - this.queuedBytes);
+    const candidates = this.queue.map((candidate, index) => ({ candidate, index })).filter(
+      ({ candidate }) => !candidate.internal && LOG_LEVEL_PRIORITY[candidate.level] < LOG_LEVEL_PRIORITY[entry.level]
+    ).toSorted((left, right) => {
+      return LOG_LEVEL_PRIORITY[left.candidate.level] - LOG_LEVEL_PRIORITY[right.candidate.level] || left.index - right.index;
+    });
+    const removedIndexes = /* @__PURE__ */ new Set();
+    let removedBytes = 0;
+    for (const { candidate, index } of candidates) {
+      removedIndexes.add(index);
+      removedBytes += candidate.bytes;
+      if (removedBytes >= requiredBytes) break;
+    }
+    if (removedBytes < requiredBytes) return false;
+    this.queue = this.queue.filter((candidate, index) => {
+      if (!removedIndexes.has(index)) return true;
+      this.queuedBytes -= candidate.bytes;
+      this.recordDrop(candidate.level);
+      return false;
+    });
+    return true;
+  }
+  recordDrop(level) {
+    this.dropped[level] += 1;
+    if (this.overflowReported) return;
+    this.overflowReported = true;
+    this.writeStderr("Log queue full; entries were dropped");
+  }
+  scheduleDrain() {
+    if (this.drainPromise) return;
+    const drain = Promise.resolve().then(() => this.drain()).catch((error) => {
+      this.discardPending();
+      this.reportWriteFailure(error);
+    });
+    this.drainPromise = drain;
+    void drain.then(() => {
+      if (this.drainPromise === drain) this.drainPromise = null;
+      if (this.queue.length > 0 || droppedCount(this.dropped) > 0) this.scheduleDrain();
+    });
+  }
+  async drain() {
+    while (this.queue.length > 0 || droppedCount(this.dropped) > 0) {
+      try {
+        await this.openCurrentFile();
+      } catch (error) {
+        this.discardPending();
+        this.reportWriteFailure(error);
+        return;
+      }
+      this.enqueueDropSummaryIfPossible();
+      if (this.queue.length === 0) return;
+      if (this.shouldRotate(this.queue[0].bytes)) await this.rotate();
+      const batch = this.takeBatch();
+      await this.appendBatch(batch);
+    }
+  }
+  enqueueDropSummaryIfPossible() {
+    if (droppedCount(this.dropped) === 0) return;
+    const summary = this.createDropSummary({ ...this.dropped });
+    if (summary.bytes > this.maxQueueBytes - this.queuedBytes) {
+      if (this.queue.length === 0) this.dropped = emptyDropCounts();
+      return;
+    }
+    this.dropped = emptyDropCounts();
+    this.queue.push({ ...summary, internal: true });
+    this.queuedBytes += summary.bytes;
+  }
+  takeBatch() {
+    const first = this.queue[0];
+    const remainingFileBytes = Math.max(0, this.maxFileBytes - this.currentBytes);
+    const batchLimit = this.currentBytes === 0 && first.bytes > this.maxFileBytes ? first.bytes : Math.min(MAX_BATCH_BYTES, remainingFileBytes);
+    let count = 0;
+    let bytes = 0;
+    for (const next of this.queue) {
+      if (count > 0 && next.bytes > batchLimit - bytes) break;
+      count += 1;
+      if (count === 1 && next.bytes > batchLimit) {
+        break;
+      }
+      bytes += next.bytes;
+    }
+    return this.queue.splice(0, count);
+  }
+  async appendBatch(batch) {
+    const bytes = batch.reduce((total, entry) => total + entry.bytes, 0);
+    this.inFlight = batch;
+    try {
+      if (!this.handle) throw new Error("Log file is not open");
+      if (this.needsRecoverySeparator && this.currentBytes > 0) {
+        await this.handle.writeFile("\n", "utf8");
+        this.currentBytes += 1;
+      }
+      this.needsRecoverySeparator = false;
+      await this.handle.writeFile(batch.map((entry) => entry.line).join(""), "utf8");
+      this.currentBytes += bytes;
+      this.writeFailureReported = false;
+      this.overflowReported = false;
+    } catch (error) {
+      this.needsRecoverySeparator = true;
+      for (const entry of batch) {
+        if (!entry.internal) this.recordDrop(entry.level);
+      }
+      await this.closeHandle();
+      this.reportWriteFailure(error);
+    } finally {
+      if (this.inFlight === batch) this.inFlight = [];
+      this.queuedBytes = Math.max(0, this.queuedBytes - bytes);
+    }
+  }
+  shouldRotate(nextBytes) {
+    return this.currentBytes > 0 && nextBytes > this.maxFileBytes - this.currentBytes;
+  }
+  async rotate() {
+    await this.closeHandle();
+    this.rotationIndex += 1;
+    const rotatedPath = join(this.logDir, `${this.prefix}-${this.rotationIndex}.log`);
+    await rename(this.currentPath, rotatedPath);
+    this.currentFileCreated = false;
+    this.currentBytes = 0;
+    await this.openCurrentFile();
+  }
+  async openCurrentFile() {
+    if (this.handle) return;
+    await this.prepareStorage();
+    const handle = await open(
+      this.currentPath,
+      this.currentFileCreated ? "a" : "ax",
+      PRIVATE_FILE_MODE
+    );
+    this.currentFileCreated = true;
+    try {
+      const stats = await handle.stat();
+      this.currentBytes = stats.size;
+      if (process.platform !== "win32") await chmod(this.currentPath, PRIVATE_FILE_MODE);
+    } catch (error) {
+      await handle.close().catch(() => void 0);
+      throw error;
+    }
+    this.handle = handle;
+    await this.pruneLogs();
+  }
+  async prepareStorage() {
+    if (this.storagePrepared) return;
+    await mkdir(this.logDir, { recursive: true, mode: PRIVATE_DIR_MODE });
+    if (process.platform !== "win32") await chmod(this.logDir, PRIVATE_DIR_MODE);
+    await this.restrictExistingLogs();
+    this.storagePrepared = true;
+  }
+  async restrictExistingLogs() {
+    if (process.platform === "win32") return;
+    const entries = await readdir(this.logDir, { withFileTypes: true });
+    await Promise.all(
+      entries.filter((entry) => entry.isFile() && isManagedLog(entry.name)).map(
+        (entry) => chmod(join(this.logDir, entry.name), PRIVATE_FILE_MODE).catch((error) => {
+          this.reportWriteFailure(error);
+        })
+      )
+    );
+  }
+  async pruneLogs() {
+    let files;
+    try {
+      files = await this.managedLogs();
+    } catch (error) {
+      this.reportWriteFailure(error);
+      return;
+    }
+    const now = Date.now();
+    for (const file of files) {
+      if (!file.isProtected && now - file.mtimeMs > this.maxAgeMs) {
+        if (await this.removeLog(file)) files = files.filter((item) => item.path !== file.path);
+      }
+    }
+    let totalBytes = files.reduce((total, file) => total + file.bytes, 0);
+    let totalFiles = files.length;
+    const candidates = files.filter((file) => !file.isProtected).toSorted(
+      (left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name)
+    );
+    for (const file of candidates) {
+      if (totalFiles <= this.maxFiles && totalBytes <= this.maxDirectoryBytes) break;
+      if (!await this.removeLog(file)) continue;
+      totalFiles -= 1;
+      totalBytes = Math.max(0, totalBytes - file.bytes);
+    }
+  }
+  async managedLogs() {
+    const entries = await readdir(this.logDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !isManagedLog(entry.name)) continue;
+      const path = join(this.logDir, entry.name);
+      try {
+        const stats = await lstat(path);
+        if (!stats.isFile()) continue;
+        const pid = activeLogPid(entry.name);
+        files.push({
+          name: entry.name,
+          path,
+          bytes: stats.size,
+          mtimeMs: stats.mtimeMs,
+          isProtected: path === this.currentPath || ORIGINAL_ACTIVE_LOG_PATTERN.test(entry.name) || pid != null && isProcessAlive(pid)
+        });
+      } catch (error) {
+        if (errorCode(error) !== "ENOENT") this.reportWriteFailure(error);
+      }
+    }
+    return files;
+  }
+  async removeLog(file) {
+    try {
+      await unlink(file.path);
+      return true;
+    } catch (error) {
+      if (errorCode(error) === "ENOENT") return true;
+      this.reportWriteFailure(error);
+      return false;
+    }
+  }
+  async finishClose() {
+    await this.flush();
+    await this.closeHandle();
+    if (this.storagePrepared) await this.pruneLogs();
+  }
+  async closeHandle() {
+    const handle = this.handle;
+    this.handle = null;
+    if (!handle) return;
+    try {
+      await handle.close();
+    } catch (error) {
+      this.reportWriteFailure(error);
+    }
+  }
+  reportWriteFailure(error) {
+    if (this.writeFailureReported) return;
+    this.writeFailureReported = true;
+    const message = error instanceof Error ? error.message : String(error);
+    this.writeStderr(`Failed to write log ${this.currentPath}: ${message}`);
+  }
+  discardPending() {
+    this.queue.splice(0);
+    this.queuedBytes = 0;
+    this.dropped = emptyDropCounts();
+  }
+  writeStderr(message) {
+    try {
+      process.stderr.write(`[codesesh] ${message}
+`);
+    } catch {
+    }
+  }
+};
+
+// src/log-record.ts
+import { createHmac } from "crypto";
+import { homedir } from "os";
+import { types } from "util";
+var LOG_SCHEMA_VERSION = 1;
+var MIN_LOG_RECORD_BYTES = 512;
+var MAX_ARRAY_ITEMS = 50;
+var MAX_OBJECT_FIELDS = 100;
+var MAX_DEPTH = 5;
+var MAX_STRING_LENGTH = 4e3;
+var MAX_SANITIZED_VALUES = 1e3;
+var REDACTED_VALUE = "[redacted]";
+var OMITTED_VALUE = "[omitted]";
+var TRUNCATED_VALUE = "[truncated]";
+var UNSERIALIZABLE_VALUE = "[unserializable]";
+var ACCESSOR_VALUE = "[accessor]";
+var CIRCULAR_VALUE = "[circular]";
+var SAFE_SENTINELS = /* @__PURE__ */ new Set([
+  ACCESSOR_VALUE,
+  CIRCULAR_VALUE,
+  OMITTED_VALUE,
+  REDACTED_VALUE,
+  TRUNCATED_VALUE,
+  UNSERIALIZABLE_VALUE
+]);
+var LOG_CONTEXT_KEYS = /* @__PURE__ */ new Set([
+  "request_id",
+  "operation_id",
+  "publication_id"
+]);
+var CORRELATION_ID_KEYS = /* @__PURE__ */ new Set([...LOG_CONTEXT_KEYS, "connection_id"]);
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "access_token",
+  "api_key",
+  "apikey",
+  "authorization",
+  "client_secret",
+  "cookie",
+  "credential",
+  "credentials",
+  "id_token",
+  "passphrase",
+  "passwd",
+  "password",
+  "private_key",
+  "refresh_token",
+  "secret",
+  "set_cookie",
+  "token"
+]);
+var OMITTED_KEYS = /* @__PURE__ */ new Set([
+  "argv",
+  "body",
+  "command_args",
+  "content",
+  "env",
+  "environment",
+  "headers",
+  "http_body",
+  "message",
+  "messages",
+  "prompt",
+  "prompts",
+  "request_body",
+  "response_body",
+  "stderr",
+  "stdout",
+  "tool_output",
+  "tool_outputs",
+  "transcript",
+  "transcripts"
+]);
+var IDENTIFIER_KEYS = /* @__PURE__ */ new Set([
+  "cursor",
+  "message_cursor",
+  "request_key",
+  "session",
+  "session_id"
+]);
+var ERROR_TEXT_KEYS = /* @__PURE__ */ new Set(["cause", "error"]);
+var KNOWN_AGENT_NAMES = new Set(AGENT_CATALOG.map(({ name }) => name));
+var HTTP_METHODS = /* @__PURE__ */ new Set(["DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"]);
+var AUDITED_STRING_VALUES = /* @__PURE__ */ new Map([
+  [
+    "mode",
+    /* @__PURE__ */ new Set([
+      "agent",
+      "bulk",
+      "incremental",
+      "invalidRoute",
+      "missingAgent",
+      "project",
+      "projects",
+      "root",
+      "session"
+    ])
+  ],
+  ["phase", /* @__PURE__ */ new Set(["measure", "mount", "nested-update", "update"])],
+  [
+    "profiler_id",
+    /* @__PURE__ */ new Set([
+      "App",
+      "InteractiveReceipt",
+      "MainContent",
+      "MessageList",
+      "OverviewScreen",
+      "SearchControls",
+      "SearchResultsPanel",
+      "SessionDetail",
+      "SessionTreeSidebar"
+    ])
+  ],
+  ["source", /* @__PURE__ */ new Set(["commit-latency", "custom-timing", "react-profiler"])],
+  ["trigger", /* @__PURE__ */ new Set(["route"])],
+  ["reason", /* @__PURE__ */ new Set(["query-cancelled"])],
+  ["exception_origin", /* @__PURE__ */ new Set(["uncaughtException", "unhandledRejection"])]
+]);
+var INTERNAL_PLAINTEXT_KEYS = /* @__PURE__ */ new Set([
+  "authentication",
+  "bind_category",
+  "cache",
+  "close_reason",
+  "context",
+  "encoding",
+  "endpoint",
+  "event",
+  "exception_origin",
+  "failure_stage",
+  "field",
+  "indexes",
+  "label",
+  "loopback_authority",
+  "message_update",
+  "operation",
+  "outcome",
+  "parameter",
+  "persistent_index_worker_job",
+  "publication_completeness",
+  "query_keys",
+  "request_type",
+  "result",
+  "route",
+  "signal",
+  "stage",
+  "state",
+  "status",
+  "transport",
+  "update",
+  "validation_outcome",
+  "version",
+  "worker_level"
+]);
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var FINGERPRINT_TOKEN_PATTERN = /^(?:error_message|field|identifier|path|string|url):[a-f0-9]{16}$/;
+var PATH_KEY_PATTERN = /(?:^|_)(?:cwd|directory|file|path|root)$/;
+var URL_KEY_PATTERN = /(?:^|_)(?:origin|url)$/;
+var SENSITIVE_KEY_SUFFIX_PATTERN = /(?:^|_)(?:api_key|authorization|cookie|credential|credentials|passphrase|passwd|password|private_key|secret|token)$/;
+var BEARER_PATTERN = /\bBearer\s+[^\s,;]+/gi;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+var SECRET_QUERY_PATTERN = /([?&](?:access_token|api_key|apikey|password|secret|token)=)[^&#\s]*/gi;
+var PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
+var INCOMPLETE_PRIVATE_KEY_PATTERN = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*$/g;
+var INCOMPLETE_JWT_PATTERN = /\beyJ[A-Za-z0-9_-]*(?:\.[A-Za-z0-9_-]*){0,2}$/g;
+var LINE_BREAK_PATTERN = /\r\n|[\n\r]/;
+function normalizedKey(key) {
+  return key.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toLowerCase();
+}
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(key) || SENSITIVE_KEY_SUFFIX_PATTERN.test(key);
+}
+function isIdentifierKey(key) {
+  return !CORRELATION_ID_KEYS.has(key) && (IDENTIFIER_KEYS.has(key) || /(?:^|_)(?:cursor|id|request_key|session_id)$/.test(key));
+}
+function isAuditedString(key, value) {
+  if ((key === "agent" || key === "agent_name" || key === "agents" || key === "failed_agents") && KNOWN_AGENT_NAMES.has(value)) {
+    return true;
+  }
+  if (key === "method" && HTTP_METHODS.has(value)) return true;
+  return AUDITED_STRING_VALUES.get(key)?.has(value) === true;
+}
+function windowsPathPattern(value) {
+  if (!/^(?:[a-z]:[\\/]|\\\\)/i.test(value)) return void 0;
+  const pattern = value.split(/[\\/]+/).map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\\\/]+");
+  return new RegExp(pattern, "gi");
+}
+var LogRecordEncoder = class {
+  fingerprintKey;
+  maxRecordBytes;
+  personalPrefixes;
+  constructor(options) {
+    this.fingerprintKey = options.fingerprintKey;
+    this.maxRecordBytes = Math.max(
+      MIN_LOG_RECORD_BYTES,
+      Number.isFinite(options.maxRecordBytes) ? Math.floor(options.maxRecordBytes) : 0
+    );
+    const personalPrefixes = [
+      [options.currentWorkingDirectory ?? process.cwd(), "<cwd>"],
+      [options.homeDirectory ?? homedir(), "~"]
+    ];
+    this.personalPrefixes = personalPrefixes.toSorted(([left], [right]) => right.length - left.length).map(([prefix, replacement]) => ({
+      prefix,
+      replacement,
+      pattern: windowsPathPattern(prefix)
+    }));
+  }
+  encode(input) {
+    const budget = this.createSanitizationBudget();
+    const trustedCorrelationIds = !input.event.startsWith("client.");
+    const fixed = {
+      schema_version: LOG_SCHEMA_VERSION,
+      ts: input.timestamp,
+      level: input.level,
+      event: this.sanitizeEvent(input.event, budget),
+      run_id: input.runId,
+      seq: input.sequence,
+      pid: input.pid,
+      ...input.threadId == null ? {} : { thread_id: input.threadId }
+    };
+    const context = this.sanitizeContext(input.context, trustedCorrelationIds, budget);
+    const data = this.sanitizeFields(input.data, trustedCorrelationIds, budget);
+    const line = `${JSON.stringify({ ...data, ...context, ...fixed })}
+`;
+    const bytes = Buffer.byteLength(line);
+    if (bytes <= this.maxRecordBytes) return { line, bytes, level: input.level };
+    const truncatedLine = `${JSON.stringify({
+      ...context,
+      ...fixed,
+      record_truncated: true,
+      original_bytes: bytes
+    })}
+`;
+    const truncatedBytes = Buffer.byteLength(truncatedLine);
+    if (truncatedBytes <= this.maxRecordBytes) {
+      return { line: truncatedLine, bytes: truncatedBytes, level: input.level };
+    }
+    const minimalLine = `${JSON.stringify({
+      schema_version: LOG_SCHEMA_VERSION,
+      ts: input.timestamp.slice(0, 40).replace(/[^0-9TZ:.-]/g, "_"),
+      level: input.level,
+      event: fixed.event.slice(0, 64),
+      record_truncated: true,
+      original_bytes: bytes
+    })}
+`;
+    return {
+      line: minimalLine,
+      bytes: Buffer.byteLength(minimalLine),
+      level: input.level
+    };
+  }
+  sanitizeForTransport(data, event = "") {
+    const sanitized = this.sanitizeFields(
+      data,
+      !event.startsWith("client."),
+      this.createSanitizationBudget()
+    );
+    const bytes = Buffer.byteLength(JSON.stringify(sanitized));
+    return bytes <= this.maxRecordBytes ? sanitized : { transport_truncated: true, original_bytes: bytes };
+  }
+  sanitizeFields(data, trustedCorrelationIds, budget) {
+    const normalized = this.sanitizeValue(
+      data,
+      "",
+      0,
+      /* @__PURE__ */ new WeakSet(),
+      trustedCorrelationIds,
+      budget
+    );
+    return normalized && typeof normalized === "object" && !Array.isArray(normalized) ? normalized : { diagnostic_data: normalized };
+  }
+  sanitizeValue(value, key, depth, ancestors, trustedCorrelationIds, budget) {
+    if (budget.remainingValues <= 0 || budget.remainingCharacters <= 0) return TRUNCATED_VALUE;
+    budget.remainingValues -= 1;
+    const normalized = normalizedKey(this.takeKeyInput(key, budget));
+    if (isSensitiveKey(normalized)) return REDACTED_VALUE;
+    if (ERROR_TEXT_KEYS.has(normalized) && typeof value === "string") {
+      return this.fingerprint("error_message", value, budget);
+    }
+    if (OMITTED_KEYS.has(normalized) && value != null && typeof value !== "number" && typeof value !== "boolean") {
+      return OMITTED_VALUE;
+    }
+    const valueType = typeof value;
+    if ((valueType === "function" || valueType === "object" && value !== null) && types.isProxy(value)) {
+      return UNSERIALIZABLE_VALUE;
+    }
+    if (value == null || typeof value === "boolean") return value;
+    if (typeof value === "number") {
+      if (Number.isFinite(value)) return value;
+      return value === Number.POSITIVE_INFINITY ? "Infinity" : value === Number.NEGATIVE_INFINITY ? "-Infinity" : "NaN";
+    }
+    if (typeof value === "bigint") {
+      return this.sanitizeString(value.toString(), normalized, budget, trustedCorrelationIds);
+    }
+    if (typeof value === "string") {
+      if (normalized === "stack") return this.sanitizeStack(value, budget);
+      return this.sanitizeString(value, normalized, budget, trustedCorrelationIds);
+    }
+    if (typeof value !== "object") return OMITTED_VALUE;
+    if (depth >= MAX_DEPTH) return TRUNCATED_VALUE;
+    if (ArrayBuffer.isView(value) || types.isAnyArrayBuffer(value)) {
+      return OMITTED_VALUE;
+    }
+    if (ancestors.has(value)) return CIRCULAR_VALUE;
+    ancestors.add(value);
+    try {
+      if (types.isDate(value)) {
+        const timestamp = Date.prototype.getTime.call(value);
+        return Number.isNaN(timestamp) ? this.takeLiteral("Invalid Date", budget) : this.takeLiteral(Date.prototype.toISOString.call(value), budget);
+      }
+      const url = this.urlString(value);
+      if (url != null) {
+        return this.sanitizeString(url, "url", budget, trustedCorrelationIds);
+      }
+      if (types.isNativeError(value)) {
+        return this.sanitizeError(value, depth, ancestors, trustedCorrelationIds, budget);
+      }
+      if (Array.isArray(value)) {
+        return this.sanitizeArray(value, key, depth, ancestors, trustedCorrelationIds, budget);
+      }
+      if (types.isMap(value)) {
+        const result = [];
+        for (const [mapKey, item] of Map.prototype.entries.call(value)) {
+          result.push([
+            this.sanitizeValue(mapKey, "key", depth + 1, ancestors, trustedCorrelationIds, budget),
+            this.sanitizeValue(item, key, depth + 1, ancestors, trustedCorrelationIds, budget)
+          ]);
+          if (result.length >= MAX_ARRAY_ITEMS || budget.remainingValues <= 0 || budget.remainingCharacters <= 0) {
+            break;
+          }
+        }
+        return result;
+      }
+      if (types.isSet(value)) {
+        const result = [];
+        for (const item of Set.prototype.values.call(value)) {
+          result.push(
+            this.sanitizeValue(item, key, depth + 1, ancestors, trustedCorrelationIds, budget)
+          );
+          if (result.length >= MAX_ARRAY_ITEMS || budget.remainingValues <= 0 || budget.remainingCharacters <= 0) {
+            break;
+          }
+        }
+        return result;
+      }
+      return this.sanitizeObject(value, depth, ancestors, trustedCorrelationIds, budget);
+    } catch {
+      return UNSERIALIZABLE_VALUE;
+    } finally {
+      ancestors.delete(value);
+    }
+  }
+  sanitizeObject(value, depth, ancestors, trustedCorrelationIds, budget) {
+    let keys;
+    try {
+      keys = Object.getOwnPropertyNames(value).slice(0, MAX_OBJECT_FIELDS);
+    } catch {
+      return UNSERIALIZABLE_VALUE;
+    }
+    const result = {};
+    for (const key of keys) {
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(value, key);
+      } catch {
+        result[this.boundedFieldName(key, budget)] = UNSERIALIZABLE_VALUE;
+        if (budget.remainingCharacters <= 0) break;
+        continue;
+      }
+      if (!descriptor) continue;
+      result[this.boundedFieldName(key, budget)] = "value" in descriptor ? this.sanitizeValue(
+        descriptor.value,
+        key,
+        depth + 1,
+        ancestors,
+        trustedCorrelationIds,
+        budget
+      ) : ACCESSOR_VALUE;
+      if (budget.remainingValues <= 0 || budget.remainingCharacters <= 0) break;
+    }
+    return result;
+  }
+  sanitizeArray(value, key, depth, ancestors, trustedCorrelationIds, budget) {
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    const length = lengthDescriptor && "value" in lengthDescriptor && typeof lengthDescriptor.value === "number" ? Math.min(lengthDescriptor.value, MAX_ARRAY_ITEMS) : 0;
+    const result = [];
+    for (let index = 0; index < length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      result.push(
+        !descriptor ? null : "value" in descriptor ? this.sanitizeValue(
+          descriptor.value,
+          key,
+          depth + 1,
+          ancestors,
+          trustedCorrelationIds,
+          budget
+        ) : ACCESSOR_VALUE
+      );
+      if (budget.remainingValues <= 0 || budget.remainingCharacters <= 0) break;
+    }
+    return result;
+  }
+  sanitizeError(error, depth, ancestors, trustedCorrelationIds, budget) {
+    const code = this.errorProperty(error, "code");
+    const cause = this.errorProperty(error, "cause");
+    const message = this.errorStringProperty(error, "message", "");
+    const stack = this.errorStringProperty(error, "stack", "");
+    return {
+      name: this.sanitizeString(
+        this.errorStringProperty(error, "name", "Error"),
+        "name",
+        budget,
+        trustedCorrelationIds
+      ),
+      message_fingerprint: this.fingerprint("error_message", message, budget),
+      stack: this.sanitizeStack(stack, budget),
+      ...code == null ? {} : {
+        code: this.sanitizeValue(
+          code,
+          "code",
+          depth + 1,
+          ancestors,
+          trustedCorrelationIds,
+          budget
+        )
+      },
+      ...cause == null ? {} : {
+        cause: this.sanitizeValue(
+          cause,
+          "cause",
+          depth + 1,
+          ancestors,
+          trustedCorrelationIds,
+          budget
+        )
+      }
+    };
+  }
+  errorProperty(error, key) {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(error, key);
+      if (!descriptor) return void 0;
+      return "value" in descriptor ? descriptor.value : ACCESSOR_VALUE;
+    } catch {
+      return UNSERIALIZABLE_VALUE;
+    }
+  }
+  errorStringProperty(error, key, fallback) {
+    const value = this.errorProperty(error, key);
+    return value == null ? fallback : typeof value === "string" ? value : UNSERIALIZABLE_VALUE;
+  }
+  urlString(value) {
+    try {
+      return URL.prototype.toString.call(value);
+    } catch {
+      return void 0;
+    }
+  }
+  createSanitizationBudget() {
+    return {
+      remainingValues: MAX_SANITIZED_VALUES,
+      remainingCharacters: Math.max(0, Math.floor(this.maxRecordBytes))
+    };
+  }
+  sanitizeContext(context, trustedCorrelationIds, budget) {
+    if (!context) return {};
+    return Object.fromEntries(
+      Object.entries(context).flatMap(
+        ([key, value]) => LOG_CONTEXT_KEYS.has(key) && typeof value === "string" && value.length > 0 ? [
+          [
+            key,
+            this.sanitizeString(value, normalizedKey(key), budget, trustedCorrelationIds).slice(
+              0,
+              160
+            )
+          ]
+        ] : []
+      )
+    );
+  }
+  sanitizeEvent(event, budget) {
+    return this.takePrefix(event, budget).trim().replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 160);
+  }
+  sanitizeString(value, key, budget, trustedCorrelationIds = false) {
+    if (FINGERPRINT_TOKEN_PATTERN.test(value) || SAFE_SENTINELS.has(value)) {
+      return this.takeLiteral(value, budget);
+    }
+    if (CORRELATION_ID_KEYS.has(key)) {
+      return trustedCorrelationIds || UUID_PATTERN2.test(value) ? this.takeLiteral(value, budget) : this.fingerprint("identifier", value, budget);
+    }
+    if (isAuditedString(key, value)) return this.takeLiteral(value, budget);
+    if (isIdentifierKey(key)) return this.fingerprint("identifier", value, budget);
+    if (trustedCorrelationIds && INTERNAL_PLAINTEXT_KEYS.has(key)) {
+      const bounded = this.takePrefix(value, budget);
+      return this.sanitizeBoundedString(bounded, key, bounded.length < value.length);
+    }
+    if (PATH_KEY_PATTERN.test(key)) return this.fingerprint("path", value, budget);
+    if (URL_KEY_PATTERN.test(key) && value.length > Math.min(MAX_STRING_LENGTH, budget.remainingCharacters)) {
+      return this.fingerprint("url", value, budget);
+    }
+    if (URL_KEY_PATTERN.test(key)) {
+      const bounded = this.takePrefix(value, budget);
+      return this.sanitizeBoundedString(bounded, key, bounded.length < value.length);
+    }
+    return this.fingerprint("string", value, budget);
+  }
+  takeLiteral(value, budget) {
+    if (value.length > budget.remainingCharacters) return TRUNCATED_VALUE;
+    budget.remainingCharacters -= value.length;
+    return value;
+  }
+  sanitizeStack(value, budget) {
+    const bounded = this.takePrefix(value, budget);
+    const inputTruncated = bounded.length < value.length;
+    const startsWithFrame = /^\s*at(?:\s|$)/.test(bounded);
+    const lineBreak = LINE_BREAK_PATTERN.exec(bounded);
+    if (!startsWithFrame && !lineBreak) return inputTruncated ? TRUNCATED_VALUE : "";
+    const stackBody = startsWithFrame ? bounded : bounded.slice(lineBreak.index + lineBreak[0].length);
+    const sanitized = this.sanitizeBoundedString(stackBody, "stack", inputTruncated);
+    return inputTruncated && !sanitized.endsWith(TRUNCATED_VALUE) ? `${sanitized}[truncated]` : sanitized;
+  }
+  sanitizeBoundedString(value, key, inputTruncated) {
+    let sanitized = value.replace(PRIVATE_KEY_PATTERN, REDACTED_VALUE).replace(BEARER_PATTERN, `Bearer ${REDACTED_VALUE}`).replace(JWT_PATTERN, REDACTED_VALUE).replace(SECRET_QUERY_PATTERN, `$1${REDACTED_VALUE}`);
+    if (inputTruncated) {
+      sanitized = sanitized.replace(INCOMPLETE_PRIVATE_KEY_PATTERN, REDACTED_VALUE).replace(INCOMPLETE_JWT_PATTERN, REDACTED_VALUE);
+    }
+    if (URL_KEY_PATTERN.test(key)) sanitized = this.sanitizeUrl(sanitized);
+    sanitized = this.replacePersonalPrefixes(sanitized);
+    return !inputTruncated && sanitized.length <= MAX_STRING_LENGTH ? sanitized : `${sanitized.slice(0, MAX_STRING_LENGTH)}[truncated]`;
+  }
+  takePrefix(value, budget) {
+    const length = Math.min(value.length, MAX_STRING_LENGTH, budget.remainingCharacters);
+    budget.remainingCharacters -= length;
+    return value.slice(0, length);
+  }
+  takeKeyInput(key, budget) {
+    const length = Math.min(key.length, MAX_STRING_LENGTH, budget.remainingCharacters);
+    budget.remainingCharacters -= length;
+    if (length >= key.length) return key;
+    if (length === 0) return "";
+    if (length < 3) return key.slice(-length);
+    const contentLength = length - 1;
+    const prefixLength = Math.ceil(contentLength / 2);
+    return `${key.slice(0, prefixLength)}_${key.slice(-(contentLength - prefixLength))}`;
+  }
+  boundedFieldName(key, budget) {
+    if (key.length <= MAX_STRING_LENGTH && key.length <= budget.remainingCharacters) {
+      budget.remainingCharacters -= key.length;
+      return key;
+    }
+    return this.fingerprint("field", key, budget);
+  }
+  sanitizeUrl(value) {
+    let url;
+    try {
+      url = new URL(value);
+    } catch {
+      return OMITTED_VALUE;
+    }
+    return url.origin === "null" ? OMITTED_VALUE : `${url.origin}/`;
+  }
+  replacePersonalPrefixes(value) {
+    return this.personalPrefixes.reduce(
+      (text, { prefix, replacement, pattern }) => pattern ? text.replace(pattern, replacement) : text.split(prefix).join(replacement),
+      value
+    );
+  }
+  fingerprint(kind, value, budget) {
+    if (FINGERPRINT_TOKEN_PATTERN.test(value)) return this.takeLiteral(value, budget);
+    const suffix = `\0${value.length}`;
+    const contentLength = MAX_STRING_LENGTH - suffix.length;
+    const prefixLength = Math.ceil(contentLength / 2);
+    const bounded = value.length <= MAX_STRING_LENGTH ? value : `${value.slice(0, prefixLength)}${value.slice(-(contentLength - prefixLength))}${suffix}`;
+    if (bounded.length > budget.remainingCharacters) return TRUNCATED_VALUE;
+    budget.remainingCharacters -= bounded.length;
+    const digest = createHmac("sha256", this.fingerprintKey).update(bounded).digest("hex").slice(0, 16);
+    return `${kind}:${digest}`;
+  }
+};
+
+// src/logging.ts
+var DEFAULT_MAX_FILE_BYTES = 5e6;
+var DEFAULT_MAX_FILES = 10;
+var DEFAULT_MAX_DIRECTORY_BYTES = 5e7;
+var DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_QUEUE_BYTES = 1e6;
+var DEFAULT_MAX_RECORD_BYTES = 64 * 1024;
+var FINGERPRINT_KEY_ENVIRONMENT_DATA = "codesesh.logging.fingerprint-key.v1";
+var LOG_CONTEXT_KEYS2 = /* @__PURE__ */ new Set([
+  "request_id",
+  "operation_id",
+  "publication_id"
+]);
+var LEVEL_WEIGHT = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function parseLevel(value) {
+  if (value === "debug" || value === "info" || value === "warn" || value === "error") {
+    return value;
+  }
+  return "info";
+}
+function positiveInteger(value, fallback) {
+  const parsed = Math.floor(value ?? Number.NaN);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function parsePositiveInteger(value, fallback) {
+  return positiveInteger(value == null ? void 0 : Number(value), fallback);
+}
+function parseMaxAge(value) {
+  const days = parsePositiveInteger(value, DEFAULT_MAX_AGE_MS / (24 * 60 * 60 * 1e3));
+  const milliseconds = days * 24 * 60 * 60 * 1e3;
+  return Number.isSafeInteger(milliseconds) ? milliseconds : DEFAULT_MAX_AGE_MS;
+}
+function getDefaultLogDir() {
+  const base = process.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache");
+  return join2(base, "codesesh", "logs");
+}
+function sharedFingerprintKey() {
+  const existing = getEnvironmentData(FINGERPRINT_KEY_ENVIRONMENT_DATA);
+  if (typeof existing === "string" && /^[a-f0-9]{64}$/.test(existing)) return existing;
+  const generated = randomBytes(32).toString("hex");
+  setEnvironmentData(FINGERPRINT_KEY_ENVIRONMENT_DATA, generated);
+  return generated;
+}
+var LOG_FINGERPRINT_KEY = sharedFingerprintKey();
+function normalizedContext(context) {
+  return Object.fromEntries(
+    Object.entries(context).flatMap(
+      ([key, value]) => LOG_CONTEXT_KEYS2.has(key) && typeof value === "string" && value.length > 0 ? [[key, value.slice(0, 160)]] : []
+    )
+  );
+}
+var AppLogger = class {
+  level;
+  runId;
+  context = new AsyncLocalStorage();
+  encoder;
+  writer;
+  workerTarget = null;
+  sequence = 0;
+  transportFailureReported = false;
+  constructor(options = {}) {
+    const logDir = options.logDir ?? process.env.CODESESH_LOG_DIR ?? getDefaultLogDir();
+    this.level = options.level ?? parseLevel(process.env.CODESESH_LOG_LEVEL);
+    this.runId = randomUUID();
+    const maxRecordBytes = positiveInteger(
+      options.maxRecordBytes,
+      parsePositiveInteger(process.env.CODESESH_LOG_MAX_RECORD_BYTES, DEFAULT_MAX_RECORD_BYTES)
+    );
+    this.encoder = new LogRecordEncoder({
+      fingerprintKey: LOG_FINGERPRINT_KEY,
+      maxRecordBytes
+    });
+    this.writer = new AsyncLogFileWriter({
+      logDir,
+      runId: this.runId,
+      maxFileBytes: positiveInteger(
+        options.maxBytes,
+        parsePositiveInteger(process.env.CODESESH_LOG_MAX_BYTES, DEFAULT_MAX_FILE_BYTES)
+      ),
+      maxFiles: positiveInteger(
+        options.maxFiles,
+        parsePositiveInteger(process.env.CODESESH_LOG_MAX_FILES, DEFAULT_MAX_FILES)
+      ),
+      maxDirectoryBytes: positiveInteger(
+        options.maxDirectoryBytes,
+        parsePositiveInteger(process.env.CODESESH_LOG_MAX_TOTAL_BYTES, DEFAULT_MAX_DIRECTORY_BYTES)
+      ),
+      maxAgeMs: positiveInteger(
+        options.maxAgeMs,
+        parseMaxAge(process.env.CODESESH_LOG_MAX_AGE_DAYS)
+      ),
+      maxQueueBytes: positiveInteger(
+        options.maxQueueBytes,
+        parsePositiveInteger(process.env.CODESESH_LOG_MAX_QUEUE_BYTES, DEFAULT_MAX_QUEUE_BYTES)
+      ),
+      createDropSummary: (counts) => this.encodeDropSummary(counts)
+    });
+  }
+  getLogPath() {
+    return this.writer.path;
+  }
+  runWithContext(context, operation) {
+    return this.context.run({ ...this.captureContext(), ...normalizedContext(context) }, operation);
+  }
+  restoreContext(context, operation) {
+    return this.context.run(normalizedContext(context), operation);
+  }
+  captureContext() {
+    return { ...this.context.getStore() };
+  }
+  forwardToParent(port, threadId2) {
+    this.workerTarget = { port, threadId: threadId2 };
+  }
+  consumeWorkerMessage(message) {
+    if (!isWorkerLogMessage(message)) return false;
+    if (LEVEL_WEIGHT[message.level] < LEVEL_WEIGHT[this.level]) return true;
+    try {
+      this.writer.enqueue(
+        this.encode({
+          timestamp: message.ts,
+          level: message.level,
+          event: message.event,
+          pid: message.pid,
+          threadId: message.threadId,
+          context: message.context,
+          data: message.data
+        })
+      );
+      this.transportFailureReported = false;
+    } catch (error) {
+      this.reportTransportFailure(error);
+    }
+    return true;
+  }
+  debug(event, data = {}) {
+    this.write("debug", event, data);
+  }
+  info(event, data = {}) {
+    this.write("info", event, data);
+  }
+  warn(event, data = {}) {
+    this.write("warn", event, data);
+  }
+  error(event, data = {}) {
+    this.write("error", event, data);
+  }
+  flush() {
+    return this.writer.flush();
+  }
+  close() {
+    return this.writer.close();
+  }
+  flushSync() {
+    this.writer.flushSync();
+  }
+  write(level, event, data) {
+    if (LEVEL_WEIGHT[level] < LEVEL_WEIGHT[this.level]) return;
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const context = this.captureContext();
+      if (this.workerTarget) {
+        this.workerTarget.port.postMessage({
+          type: WORKER_LOG_MESSAGE_TYPE,
+          ts: timestamp,
+          level,
+          event,
+          pid: process.pid,
+          threadId: this.workerTarget.threadId,
+          context,
+          data: this.encoder.sanitizeForTransport(data, event)
+        });
+        this.transportFailureReported = false;
+        return;
+      }
+      this.writer.enqueue(
+        this.encode({
+          timestamp,
+          level,
+          event,
+          pid: process.pid,
+          context,
+          data
+        })
+      );
+    } catch (error) {
+      this.reportTransportFailure(error);
+    }
+  }
+  encode(input) {
+    this.sequence += 1;
+    return this.encoder.encode({
+      ...input,
+      runId: this.runId,
+      sequence: this.sequence
+    });
+  }
+  encodeDropSummary(counts) {
+    return this.encode({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "warn",
+      event: "logger.records_dropped",
+      pid: process.pid,
+      data: { ...counts }
+    });
+  }
+  reportTransportFailure(error) {
+    if (this.transportFailureReported) return;
+    this.transportFailureReported = true;
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      process.stderr.write(`[codesesh] Failed to prepare log entry: ${message}
+`);
+    } catch {
+    }
+  }
+};
+var appLogger = new AppLogger();
+function logSearchIndexSync(context, result, data = {}) {
+  if (result?.failures?.length) {
+    appLogger.warn("search_index.sessions_skipped", {
+      context,
+      agent: result.agentName,
+      failures: result.failures
+    });
+  }
+  if (!result) return;
+  const detail = {
+    context,
+    agent: result.agentName,
+    mode: result.mode,
+    sessions: result.sessions,
+    changed: result.changed,
+    deleted: result.deleted,
+    indexed: result.indexed,
+    skipped: result.skipped,
+    duration_ms: Math.round(result.durationMs),
+    planning_ms: Math.round(result.planningDurationMs),
+    get_session_data_calls: result.getSessionDataCalls,
+    reused_materializations: result.reusedMaterializations,
+    get_session_data_ms: Math.round(result.getSessionDataDurationMs),
+    materialization_ms: Math.round(result.materializationDurationMs),
+    rebuild_duration_ms: result.rebuildDurationMs != null ? Math.round(result.rebuildDurationMs) : void 0,
+    ...data
+  };
+  if (result.mode === "bulk") appLogger.info("search_index.sync", detail);
+  else appLogger.debug("search_index.sync", detail);
+}
+
+// src/diagnostics-bridge.ts
+import { parentPort, threadId } from "worker_threads";
+if (parentPort) appLogger.forwardToParent(parentPort, threadId);
+setCoreDiagnostics({
+  info(event, detail) {
+    appLogger.info(event, detail);
+  },
+  warn(event, detail) {
+    appLogger.warn(event, detail);
+  }
+});
+
+export {
+  appLogger,
+  logSearchIndexSync
+};
+//# sourceMappingURL=chunk-4QFNZCBR.js.map