@wenathlan/devthink 2.0.12 → 2.0.14

package/core.ts

@@ -0,0 +1,1473 @@
+/**
+ * @file core.ts — generic pure utilities shared by every domain module.
+ *
+ * Third-person observer view — library-first, root-first, production-ready.
+ *
+ * v2.1.15 Phase A consolidation: this module is now a TRUE leaf of the
+ * dependency DAG (imports only constants.js below it plus node:* builtins).
+ * Every legacy compact duplicate that used to live here — the short-named
+ * request builders (transformRequest, buildAntigravity, buildGeminiCLI,
+ * fetchCascade), the SSE transformers (parseSSEChunk, normalizePayloads,
+ * transformToOpenAI, transformToAnthropic), the model classifiers (isCLIOnly,
+ * isImageModel, resolveModelId, parseVariant, BUDGET_MAP, mapBudget,
+ * endpointsForModel), the identity helpers (ua, apiClient, fingerprint), the
+ * schema cleaner (cleanSchema, ALLOWED), the header stripper (FORBIDDEN,
+ * stripForbidden), the id generators (genId, sessId, upId), sanitizeToolName,
+ * normalizeRole, TOOL_REGEX and withAutoRecovery — was a dead duplicate of the
+ * canonical implementation in its domain owner and was deleted.
+ *
+ * v2.1.15 Phase B consolidation: this module absorbed the generic utility
+ * families that used to be duplicated across the tree — fnv1a64 (fingerprint
+ * hex-string lineage + the request bigint lineage, now accurately split into
+ * fnv1a64 / fnv1a64Bytes), getJitter (constants, plugin), getJitterMs
+ * (fingerprint, models), pickRandom (constants, fingerprint), isRetryable
+ * (auth, plugin, project), isRetryableStatus (models, request, search) and
+ * fetchWithTimeout (models, plugin, project, quota, search, version, auth's
+ * fetchTimeout). Every other module imports these from core.js.
+ */
+import { randomInt } from "node:crypto";
+import { FETCH_TIMEOUT_MS, JITTER_MAX_MS, JITTER_MIN_MS } from "./constants.js";
+
+/**
+ * FNV-1a 32-bit hash over a UTF-16 string (per code unit), unsigned.
+ * Canonical implementation of the fnv1a32 family — every other module
+ * imports this instead of redefining it.
+ */
+export const fnv1a32 = (s: string): number => {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+};
+
+/**
+ * Hex form of {@link fnv1a32}, zero-padded to 8 characters.
+ */
+export const fnv1a32Hex = (s: string): string => fnv1a32(s).toString(16).padStart(8, "0");
+
+/**
+ * FNV-1a 64-bit hash over UTF-16 code units, returned as a 16-char
+ * zero-padded lowercase hex string (fingerprint lineage — canonical of the
+ * fnv1a64 family). Uses the FNV-1a 64 offset basis 14695981039346656037 and
+ * prime 1099511628211 as inline literals; the 32-bit FNV constants live in
+ * constants.ts but the 64-bit pair is only used here, so it stays local and
+ * documented rather than imported.
+ */
+export function fnv1a64(input: string): string {
+  let hash = 14695981039346656037n;
+  const prime = 1099511628211n;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = (hash * prime) & 0xffffffffffffffffn;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+/**
+ * FNV-1a 64-bit hash over UTF-8 BYTES, returned as a bigint (request.ts
+ * lineage — the long deterministic-id digest). Distinct from
+ * {@link fnv1a64}: this variant hashes bytes (Buffer.from(input, "utf8"))
+ * instead of UTF-16 code units, so the two produce different digests for
+ * non-ASCII input and different return types; the accurate split keeps both
+ * historical behaviors available under honest names.
+ */
+export function fnv1a64Bytes(input: string): bigint {
+  let hash = 14695981039346656037n;
+  const prime = 1099511628211n;
+  const buf = Buffer.from(input, "utf8");
+  for (let i = 0; i < buf.length; i++) {
+    hash ^= BigInt(buf[i]!);
+    hash = (hash * prime) & 0xffffffffffffffffn;
+  }
+  return hash;
+}
+
+/**
+ * Uniform jitter in [JITTER_MIN_MS, JITTER_MAX_MS] (0-80 ms) for cascade
+ * backoff randomization. Prefers the crypto-strong randomInt and falls back
+ * to Math.random. Same value distribution as {@link getJitter}.
+ */
+export const jitter = (): number => {
+  try {
+    return randomInt(JITTER_MIN_MS, JITTER_MAX_MS + 1);
+  } catch {
+    return Math.floor(Math.random() * (JITTER_MAX_MS - JITTER_MIN_MS + 1)) + JITTER_MIN_MS;
+  }
+};
+
+/**
+ * Jitter draw in [JITTER_MIN_MS, JITTER_MAX_MS] (0-80 ms) — the historical
+ * getJitter name used by the cascade/retry loops. Identical distribution to
+ * {@link jitter}; both names are kept because both are published.
+ */
+export function getJitter(): number {
+  return jitter();
+}
+
+/**
+ * Bounded jitter value in the inclusive [minMs, maxMs] range (defaults
+ * 0-80 ms). Crypto-strong randomInt with a Math.random fallback; used for
+ * Retry-After throttling and anti-rate-limit delays.
+ */
+export function getJitterMs(minMs = 0, maxMs = 80): number {
+  try {
+    return randomInt(minMs, maxMs + 1);
+  } catch {
+    return Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+  }
+}
+
+/**
+ * Picks a uniformly random element from a readonly pool. Crypto-strong
+ * randomInt with a Math.random fallback (canonical of the pickRandom family;
+ * the former constants.ts Math.random variant and the fingerprint.ts
+ * secureRandom variant merge here — same distribution, stronger draw).
+ */
+export function pickRandom<T>(pool: readonly T[]): T {
+  try {
+    return pool[randomInt(0, pool.length)]!;
+  } catch {
+    return pool[Math.floor(Math.random() * pool.length)]!;
+  }
+}
+
+/**
+ * Retry classification for the auth/project-discovery flows:
+ * 403, 404, 408, 429 and every 5xx are retryable. Canonical of the
+ * isRetryable family (auth.ts and project.ts lineages; the plugin.ts
+ * 3-condition variant had zero callers and was dropped).
+ */
+export function isRetryable(status: number): boolean {
+  return status === 403 || status === 404 || status === 408 || status === 429 || status >= 500;
+}
+
+/**
+ * Retry classification for the endpoint-cascade flows: 403 (project IAM
+ * mismatch), 404 (rollout), 429 (rate limit) and the whole 5xx range.
+ * Canonical of the isRetryableStatus family — the live-validated request.ts
+ * cascade variant (408 is intentionally NOT retryable here; streaming.ts
+ * keeps its own list-driven transient variant under an accurate name).
+ */
+export function isRetryableStatus(status: number): boolean {
+  if (!Number.isFinite(status)) return false;
+  return status === 429 || status === 403 || status === 404 || (status >= 500 && status <= 599);
+}
+
+/**
+ * Fetch with an abort-controller timeout and external-signal merge. Canonical
+ * of the fetchWithTimeout family (supersedes the auth.ts fetchTimeout alias:
+ * same positional signature and same 10s default). Behavior notes:
+ * - timeout default FETCH_TIMEOUT_MS (10s); pass the third argument to
+ *   override (quota callers pass QUOTA_TIMEOUT_MS, version callers the 5s
+ *   VERSION_FETCH_TIMEOUT_MS);
+ * - an init.signal is merged with the timer: either aborting aborts the
+ *   fetch (an already-aborted external signal aborts immediately);
+ * - a `timeoutMs` property inside init (the models.ts lineage call style)
+ *   takes precedence over the positional default;
+ * - AbortError propagates unwrapped — consumers that historically mapped it
+ *   to a domain error (ProjectDiscoveryError 408 in project.ts, the plain
+ *   timeout Errors in plugin/quota) wrap THIS call at their call sites.
+ */
+export async function fetchWithTimeout(
+  url: string,
+  init: RequestInit = {},
+  timeoutMs: number = FETCH_TIMEOUT_MS,
+): Promise<Response> {
+  const timeout = (init as RequestInit & { timeoutMs?: number }).timeoutMs ?? timeoutMs;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  const external = init.signal as AbortSignal | undefined | null;
+  if (external) {
+    if (external.aborted) controller.abort();
+    else external.addEventListener("abort", () => controller.abort(), { once: true });
+  }
+
+  try {
+    const { timeoutMs: _t, signal: _s, ...rest } = init as Record<string, unknown>;
+    return await fetch(url, { ...rest, signal: controller.signal } as RequestInit);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * LRU map with O(1) re-insertion refresh; evicts the least-recently-used
+ * entry once the capacity is exceeded.
+ */
+class LRU<K, V> extends Map<K, V> {
+  constructor(private max = 100) {
+    super();
+  }
+
+  override set(k: K, v: V) {
+    if (this.has(k)) this.delete(k);
+    super.set(k, v);
+    if (this.size > this.max) {
+      const first = this.keys().next().value;
+      if (first !== undefined) this.delete(first);
+    }
+    return this;
+  }
+}
+
+/**
+ * Shared LRU(100) cache keyed by session/model for thinking signatures.
+ * The single shared instance consumed by streaming.ts.
+ */
+export const thinkingCache = new LRU<string, string>(100);
+
+/* ── Merged: the grand merge section ── the correlated debug logging logics of the merged repository interned here, one surface without duplicate variations. ── */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// ---------------------------------------------------------------------------
+// Governance constants — identical values owned by constants.ts
+// ---------------------------------------------------------------------------
+
+import { DEBUG_BUFFER_TUI_LINES, DEBUG_LOG_MAX_BYTES, DEBUG_LOG_RETENTION_DAYS } from "./constants.js";
+import { cfgDir } from "./config.js";
+export { DEBUG_BUFFER_TUI_LINES, DEBUG_LOG_MAX_BYTES, DEBUG_LOG_RETENTION_DAYS };
+
+// ---------------------------------------------------------------------------
+// Section: Gemini CLI bypass context (documentation constant)
+// ---------------------------------------------------------------------------
+
+// v2.1.16 dead-code cleanup: the GEMINI_CLI_CONTEXT documentation aggregate
+// had zero consumers repo-wide and was deleted. It carried a verbatim GOCSPX
+// client-secret fragment and phantom model ids (gemini-2.0-flash-thinking-exp,
+// gemini-antigravity-preview) that exist in no owner module; the real values
+// live in constants.js (oauth pair, user agent, metadata, base url,
+// PROJECT_FALLBACK) and models.js (model identification).
+
+// ---------------------------------------------------------------------------
+// Section: Governance constants (filesystem layout and limits)
+// ---------------------------------------------------------------------------
+// DEBUG_LOG_MAX_BYTES (10MB), DEBUG_LOG_RETENTION_DAYS (7) and
+// DEBUG_BUFFER_TUI_LINES (1000) are imported from constants.js (identical
+// values) and re-exported above.
+
+/** Relative log dir from $HOME: ~/.config/opencode/antigravity-logs/ */
+export const DEBUG_LOG_DIR_SUBPATH = ".config/opencode/antigravity-logs";
+
+/** Active log filename */
+export const DEBUG_LOG_FILE_NAME = "antigravity.log";
+
+// Internal aliases kept from the legacy variant for readability below.
+const PLUGIN_DIR_NAME = "opencode";
+const LOG_SUBDIR = "antigravity-logs";
+const LOG_FILE_NAME = DEBUG_LOG_FILE_NAME;
+const MAX_FILE_SIZE_BYTES = DEBUG_LOG_MAX_BYTES;
+const MAX_FILE_AGE_MS = DEBUG_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+const TUI_BUFFER_CAPACITY = DEBUG_BUFFER_TUI_LINES;
+
+/** Cleanup trigger: check for expired logs every N writes */
+const CLEANUP_EVERY_WRITES = 50;
+
+function getDefaultLogDir(): string {
+  // Same result as path.join(home, ".config", "opencode", "antigravity-logs"),
+  // derived from the exported governance constant.
+  return path.join(os.homedir(), ...DEBUG_LOG_DIR_SUBPATH.split("/"));
+}
+
+function getLogFilePath(logDir: string): string {
+  return path.join(logDir, LOG_FILE_NAME);
+}
+
+// ---------------------------------------------------------------------------
+// Section: Log levels (reconciled enum)
+// -----------------------------------------------------------------------------
+/**
+ * Reconciliation note: two numeric scales existed (0/1/2/3/99 legacy and
+ * 10/20/30/40/100 observer). The legacy compact scale is canonical because it
+ * is the merge base; environment parsing accepts BOTH numeric scales (see
+ * {@link parseAntigravityDebugEnv}).
+ */
+export type LogLevelName = "debug" | "info" | "warn" | "error" | "silent";
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  SILENT = 99,
+}
+
+const LEVEL_NAME_TO_ENUM: Record<string, LogLevel> = {
+  debug: LogLevel.DEBUG,
+  info: LogLevel.INFO,
+  warn: LogLevel.WARN,
+  warning: LogLevel.WARN, // compat alias accepted from the observer variant
+  error: LogLevel.ERROR,
+  silent: LogLevel.SILENT,
+};
+
+const LEVEL_ENUM_TO_NAME: Record<LogLevel, string> = {
+  [LogLevel.DEBUG]: "DEBUG",
+  [LogLevel.INFO]: "INFO",
+  [LogLevel.WARN]: "WARN",
+  [LogLevel.ERROR]: "ERROR",
+  [LogLevel.SILENT]: "SILENT",
+};
+
+/** Returns the first defined value among the given env variable names. */
+function readFirstEnv(env: NodeJS.ProcessEnv, names: readonly string[]): string | undefined {
+  for (const name of names) {
+    const value = env[name];
+    if (value !== undefined) return value;
+  }
+  return undefined;
+}
+
+function parseBooleanEnv(value: string | undefined, defaultValue: boolean): boolean {
+  if (value === undefined) return defaultValue;
+  const v = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on", "enabled"].includes(v)) return true;
+  if (["0", "false", "no", "off", "disabled"].includes(v)) return false;
+  return defaultValue;
+}
+
+// ---------------------------------------------------------------------------
+// Section: Environment parsing (ANTIGRAVITY_DEBUG / OPENCODE_ANTIGRAVITY_DEBUG)
+// ---------------------------------------------------------------------------
+
+export interface EnvParseResult {
+  /** true = logging active, false = completely silenced */
+  enabled: boolean;
+  /** Minimum level that will be emitted */
+  level: LogLevel;
+  /** Raw env string kept for debugging/introspection */
+  raw: string | undefined;
+}
+
+/** Tokens meaning "logger fully off". Matched against trimmed lowercase input. */
+const DISABLED_TOKENS = new Set(["0", "false", "off", "disabled", "no", "none", ""]);
+
+/** Tokens meaning "full debug enable" (most verbose level). */
+const DEBUG_ENABLE_TOKENS = new Set(["1", "true", "yes", "on", "*", "all", "debug", "verbose", "trace", "silly"]);
+
+/**
+ * Parses the debug env value (ANTIGRAVITY_DEBUG or
+ * OPENCODE_ANTIGRAVITY_DEBUG) into an enabled flag plus minimum level.
+ *
+ * Rules (merged from both variants):
+ * - undefined            => enabled true, level WARN (observer default)
+ * - disabled tokens      => enabled false, SILENT (0/false/off/disabled/no/none/"")
+ * - enable tokens        => DEBUG (1/true/yes/on/star/all/debug/verbose/trace/silly)
+ * - numeric values       => legacy scale 0..3 maps directly onto LogLevel;
+ *                           observer scale 10..40 maps DEBUG/INFO/WARN/ERROR;
+ *                           values >= 99 map to SILENT (legacy sentinel);
+ *                           anything else falls back to WARN
+ * - comma/semicolon/space/pipe separated lists pick the most verbose level
+ *   mentioned (substring matching included, wildcards force DEBUG)
+ * - any other non-empty string defaults to DEBUG (user explicitly opted in)
+ *
+ * @param raw - raw env value
+ */
+export function parseAntigravityDebugEnv(raw: string | undefined): EnvParseResult {
+  if (raw === undefined) {
+    return { enabled: true, level: LogLevel.WARN, raw };
+  }
+  const trimmed = String(raw).trim();
+  const lower = trimmed.toLowerCase();
+
+  if (DISABLED_TOKENS.has(lower)) {
+    // Explicit empty string counts as disabled when set; undefined stays default WARN.
+    return { enabled: false, level: LogLevel.SILENT, raw: trimmed };
+  }
+
+  if (DEBUG_ENABLE_TOKENS.has(lower)) {
+    return { enabled: true, level: LogLevel.DEBUG, raw: trimmed };
+  }
+
+  // Numeric quick path accepting both reconciled scales.
+  if (/^\d+$/.test(lower)) {
+    const n = Number(lower);
+    if (n >= 99) return { enabled: false, level: LogLevel.SILENT, raw: trimmed };
+    if (n <= 3) return { enabled: true, level: n as LogLevel, raw: trimmed }; // legacy direct cast
+    if (n <= 10) return { enabled: true, level: LogLevel.DEBUG, raw: trimmed };
+    if (n <= 20) return { enabled: true, level: LogLevel.INFO, raw: trimmed };
+    if (n <= 30) return { enabled: true, level: LogLevel.WARN, raw: trimmed };
+    if (n <= 40) return { enabled: true, level: LogLevel.ERROR, raw: trimmed };
+    return { enabled: true, level: LogLevel.WARN, raw: trimmed };
+  }
+
+  // Multi-token list: choose the most verbose (lowest numeric) level mentioned.
+  const tokens = lower
+    .split(/[,;\s|]+/g)
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  let minLevel: LogLevel | null = null;
+  for (const tok of tokens) {
+    if (tok in LEVEL_NAME_TO_ENUM) {
+      const lvl = LEVEL_NAME_TO_ENUM[tok];
+      if (lvl !== undefined && (minLevel === null || lvl < minLevel)) minLevel = lvl;
+      continue;
+    }
+    for (const [name, lvl] of Object.entries(LEVEL_NAME_TO_ENUM)) {
+      if (tok.includes(name)) {
+        if (minLevel === null || lvl < minLevel) minLevel = lvl;
+      }
+    }
+    if (tok.includes("*")) {
+      if (minLevel === null || LogLevel.DEBUG < minLevel) minLevel = LogLevel.DEBUG;
+    }
+  }
+
+  if (minLevel !== null) {
+    return { enabled: true, level: minLevel, raw: trimmed };
+  }
+
+  // Non-empty unknown string => DEBUG (user explicitly wanted logging).
+  if (trimmed.length > 0) {
+    return { enabled: true, level: LogLevel.DEBUG, raw: trimmed };
+  }
+
+  return { enabled: true, level: LogLevel.WARN, raw: trimmed };
+}
+
+// ---------------------------------------------------------------------------
+// Section: Secret redaction
+// ---------------------------------------------------------------------------
+
+/**
+ * Legacy pattern list: covers GOCSPX client secrets, OAuth client IDs,
+ * Bearer tokens, generic OAuth fields, query-string tokens, JWT-like
+ * triples and X-Goog headers.
+ */
+const SECRET_PATTERNS: Array<{ regex: RegExp; replacement: string }> = [
+  // Full GOCSPX client secret
+  { regex: /GOCSPX-[A-Za-z0-9_\-]{20,}/g, replacement: "GOCSPX-***REDACTED***" },
+  // Client ID patterns (avoid leaking the full identifier in logs)
+  { regex: /681255809395-[a-z0-9]{20,}\.apps\.googleusercontent\.com/gi, replacement: "***CLIENT_ID_REDACTED***" },
+  { regex: /\b681255809395-oo8f…b135j\b/g, replacement: "***CLIENT_ID_REDACTED***" },
+
+  // Bearer tokens - header form or bare value
+  { regex: /(Bearer\s+)[A-Za-z0-9\-_\.=]+/gi, replacement: "$1***REDACTED***" },
+  { regex: /(Authorization['"]?\s*[:=]\s*['"]?)(Bearer\s+)?[A-Za-z0-9\-_\.]+/gi, replacement: "$1***REDACTED***" },
+
+  // Generic OAuth fields
+  {
+    regex:
+      /("?(?:access_token|refresh_token|id_token|client_secret|api_key|apikey|idToken|accessToken|refreshToken)"?\s*[:=]\s*["']?)([^"'\s,}\]]+)/gi,
+    replacement: "$1***REDACTED***",
+  },
+
+  // access_token as query parameter
+  { regex: /([?&](?:access_token|id_token|refresh_token|api_key|key)=)([^&\s]+)/gi, replacement: "$1***REDACTED***" },
+
+  // JWT-like tokens (three base64 parts)
+  { regex: /\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\b/g, replacement: "***JWT_REDACTED***" },
+
+  // Google OAuth access tokens (ya29.*)
+  { regex: /\b(ya29\.[A-Za-z0-9_\-]+)\b/g, replacement: "ya29.***REDACTED***" },
+
+  // X-Goog headers carrying tokens
+  { regex: /(X-Goog-[A-Za-z\-]+:\s*)(.+)/gi, replacement: "$1***REDACTED***" },
+];
+
+/**
+ * Redacts known secrets inside free-form text using the legacy pattern list.
+ * @param input - raw log line or message
+ */
+export function redactSecretsPatterns(input: string): string {
+  let out = input;
+  for (const { regex, replacement } of SECRET_PATTERNS) {
+    // Reset lastIndex so globally reused regexes stay safe inside loops.
+    regex.lastIndex = 0;
+    out = out.replace(regex, replacement);
+  }
+  return out;
+}
+
+/**
+ * Text redactor from the observer variant. Complements {@link redactSecretsPatterns}
+ * with JSON/query key=value captures, long Bearer tokens, ya29.* Google OAuth
+ * access tokens and AIza* Google API keys.
+ * @param input - raw log line or message
+ */
+export function redactSecretsText(input: string): string {
+  if (!input || typeof input !== "string") return input as unknown as string;
+  let out = input;
+
+  // 1. JSON / query style separators - capture key+separator, replace value.
+  //    Value must be at least 8 chars to avoid false positives.
+  out = out.replace(
+    /(["']?(?:refresh_token|access_token|id_token|api_key|api[_-]?key|client_secret|client_id)["']?\s*[:=]\s*["']?)([^"'\s,;}\]&]{8,})/gi,
+    (_m, p1: string) => `${p1}[REDACTED]`,
+  );
+
+  // 2. Bearer header with long token
+  out = out.replace(/(Bearer\s+)[A-Za-z0-9\-_\.=]{20,}/gi, "$1[REDACTED]");
+
+  // 3. Google OAuth access tokens ya29.*
+  out = out.replace(/\bya29\.[A-Za-z0-9\-_]{20,}/g, "[REDACTED_GOOGLE_TOKEN]");
+
+  // 4. Google API keys AIza*
+  out = out.replace(/\bAIza[0-9A-Za-z\-_]{30,}/g, "[REDACTED_API_KEY]");
+
+  // 5. Generic secret=/password=/token= assignments with long values (>=12 chars)
+  out = out.replace(
+    /((?:secret|password|token)\s*[:=]\s*["']?)([^"'\s]{12,})/gi,
+    (_m, p1: string) => `${p1}[REDACTED]`,
+  );
+
+  return out;
+}
+
+/** Sensitive substrings for object-key based redaction (defense in depth). */
+const SENSITIVE_KEY_SUBSTRINGS = [
+  "refresh_token",
+  "access_token",
+  "id_token",
+  "api_key",
+  "apikey",
+  "api-key",
+  "client_secret",
+  "client_secret_expires",
+  "password",
+] as const;
+
+/** Legacy exact-key sensitive set used by {@link redactObject}. */
+const LEGACY_SENSITIVE_KEYS = new Set([
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "client_secret",
+  "clientSecret",
+  "accessToken",
+  "refreshToken",
+  "idToken",
+  "api_key",
+  "apikey",
+  "token",
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-goog-api-key",
+]);
+
+/** Checks whether an object key name is considered sensitive. */
+function isSensitiveKey(key: string): boolean {
+  const low = key.toLowerCase();
+  return SENSITIVE_KEY_SUBSTRINGS.some((s) => low.includes(s));
+}
+
+/**
+ * Legacy shallow-cloning redaction: redacts sensitive keys and string values
+ * recursively (without circular-reference protection).
+ */
+export function redactObject<T>(obj: T): T {
+  if (obj === null || obj === undefined) return obj;
+  if (typeof obj === "string") {
+    return redactSecretsPatterns(obj) as unknown as T;
+  }
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return (obj as unknown as Array<unknown>).map(redactObject) as unknown as T;
+  }
+  const copy: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+    if (LEGACY_SENSITIVE_KEYS.has(k.toLowerCase()) || LEGACY_SENSITIVE_KEYS.has(k)) {
+      copy[k] = "***REDACTED***";
+    } else if (typeof v === "string") {
+      copy[k] = redactSecretsPatterns(v);
+    } else if (typeof v === "object" && v !== null) {
+      copy[k] = redactObject(v);
+    } else {
+      copy[k] = v;
+    }
+  }
+  return copy as unknown as T;
+}
+
+/**
+ * Deep redaction that clones and redacts sensitive keys and string values.
+ * Handles circular references (replaced with "[Circular]"), Error objects
+ * (name/message/stack plus enumerable props) and arrays. Never throws.
+ *
+ * @param value - arbitrary value to clone/redact
+ * @param seen - internal WeakSet tracking visited objects
+ */
+export function redactObjectDeep<T>(value: T, seen = new WeakSet<object>()): T {
+  if (value === null || value === undefined) return value;
+  const t = typeof value;
+  if (t === "string") {
+    return redactSecretsText(value as unknown as string) as unknown as T;
+  }
+  if (t !== "object") {
+    // number, boolean, bigint, symbol, function - returned as-is
+    return value;
+  }
+
+  // Circular reference guard
+  if (seen.has(value as unknown as object)) {
+    return "[Circular]" as unknown as T;
+  }
+
+  // Error special handling - capture name/message/stack redacted
+  if (value instanceof Error) {
+    seen.add(value as unknown as object);
+    const errObj: Record<string, unknown> = {
+      name: (value as Error).name,
+      message: redactSecretsText((value as Error).message),
+    };
+    const stack = (value as Error).stack;
+    if (stack) errObj.stack = redactSecretsText(stack);
+    for (const k of Object.keys(value as unknown as object)) {
+      if (k === "message" || k === "stack" || k === "name") continue;
+      try {
+        const v = (value as unknown as Record<string, unknown>)[k];
+        if (isSensitiveKey(k)) {
+          errObj[k] = "[REDACTED]";
+        } else {
+          errObj[k] = redactObjectDeep(v as unknown, seen);
+        }
+      } catch {
+        errObj[k] = "[Unserializable]";
+      }
+    }
+    return errObj as unknown as T;
+  }
+
+  // Arrays
+  if (Array.isArray(value)) {
+    seen.add(value as unknown as object);
+    const arr = value as unknown as unknown[];
+    const out: unknown[] = new Array(arr.length);
+    for (let i = 0; i < arr.length; i++) {
+      try {
+        out[i] = redactObjectDeep(arr[i] as unknown, seen);
+      } catch {
+        out[i] = "[Unserializable]";
+      }
+    }
+    return out as unknown as T;
+  }
+
+  // Plain objects / records
+  const obj = value as unknown as Record<string, unknown>;
+  seen.add(obj as unknown as object);
+  const cloned: Record<string, unknown> = {};
+  for (const key of Object.keys(obj)) {
+    try {
+      const v = obj[key];
+      if (isSensitiveKey(key)) {
+        cloned[key] = "[REDACTED]";
+      } else {
+        cloned[key] = redactObjectDeep(v as unknown, seen);
+      }
+    } catch {
+      cloned[key] = "[Unserializable]";
+    }
+  }
+  return cloned as unknown as T;
+}
+
+/**
+ * Safe JSON stringify that never throws; runs the deep redaction layer first.
+ */
+function safeStringifyMeta(meta: unknown): string {
+  if (meta === undefined) return "";
+  if (meta === null) return "null";
+  try {
+    const redacted = redactObjectDeep(meta);
+    return JSON.stringify(redacted);
+  } catch {
+    try {
+      return String(meta);
+    } catch {
+      return "[Unserializable meta]";
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Section: TUI circular buffer
+// ---------------------------------------------------------------------------
+
+export interface LogEntry {
+  timestamp: string; // ISO string
+  level: LogLevel;
+  levelName: string;
+  message: string;
+  data?: unknown | undefined;
+  scope?: string | undefined;
+}
+
+export class CircularBuffer<T> {
+  private buf: (T | undefined)[];
+  private head = 0;
+  private count = 0;
+
+  constructor(public readonly capacity: number) {
+    this.buf = new Array<T | undefined>(capacity);
+  }
+
+  push(item: T): void {
+    this.buf[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) this.count++;
+  }
+
+  toArray(): T[] {
+    const result: T[] = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const idx = (start + i) % this.capacity;
+      const val = this.buf[idx];
+      if (val !== undefined) result.push(val);
+    }
+    return result;
+  }
+
+  clear(): void {
+    this.buf = new Array<T | undefined>(this.capacity);
+    this.head = 0;
+    this.count = 0;
+  }
+
+  get size(): number {
+    return this.count;
+  }
+
+  getRecent(n: number): T[] {
+    const all = this.toArray();
+    return all.slice(-n);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Section: Logger singleton (merged feature set)
+// ---------------------------------------------------------------------------
+
+export interface DebugLoggerOptions {
+  logDir?: string;
+  level?: LogLevel | LogLevelName;
+  tuiEnabled?: boolean;
+  tuiCapacity?: number;
+  quietMode?: boolean;
+  enableFileLogging?: boolean;
+  /** Allows injecting env for tests */
+  env?: NodeJS.ProcessEnv;
+}
+
+export class DebugLogger {
+  private static _instance: DebugLogger | null = null;
+
+  public readonly logDir: string;
+  public readonly logFile: string;
+  private level: LogLevel;
+  /** Observer-style master switch: false means completely silenced. */
+  private enabled: boolean;
+  /** Raw debug env value last seen (for introspection). */
+  private rawEnv: string | undefined;
+  private tuiEnabled: boolean;
+  private quietMode: boolean;
+  private fileLoggingEnabled: boolean;
+  private buffer: CircularBuffer<LogEntry>;
+  private dirEnsured = false;
+  private lastCleanup = 0;
+  private readonly CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1h throttle
+  private writeCount = 0;
+
+  // Guards against recursion if fs fails while logging the failure itself.
+  private isWriting = false;
+
+  private constructor(opts: DebugLoggerOptions = {}) {
+    const env = opts.env ?? process.env;
+
+    this.logDir = opts.logDir ?? getDefaultLogDir();
+    this.logFile = getLogFilePath(this.logDir);
+
+    // Level control: OPENCODE_ANTIGRAVITY_DEBUG first, ANTIGRAVITY_DEBUG compat.
+    const envLevelRaw = readFirstEnv(env, ["OPENCODE_ANTIGRAVITY_DEBUG", "ANTIGRAVITY_DEBUG"]);
+    this.rawEnv = envLevelRaw;
+
+    if (opts.level !== undefined) {
+      this.level = typeof opts.level === "string" ? this.parseLevelOption(opts.level, LogLevel.INFO) : opts.level;
+      this.enabled = this.level !== LogLevel.SILENT;
+    } else if (envLevelRaw !== undefined) {
+      const parsed = parseAntigravityDebugEnv(envLevelRaw);
+      this.level = parsed.level;
+      this.enabled = parsed.enabled;
+    } else {
+      // Default INFO when neither option nor env is provided.
+      this.level = LogLevel.INFO;
+      this.enabled = true;
+    }
+
+    // TUI control: OPENCODE_ANTIGRAVITY_DEBUG_TUI first, ANTIGRAVITY_DEBUG_TUI compat.
+    const envTuiRaw = readFirstEnv(env, ["OPENCODE_ANTIGRAVITY_DEBUG_TUI", "ANTIGRAVITY_DEBUG_TUI"]);
+    if (opts.tuiEnabled !== undefined) {
+      this.tuiEnabled = opts.tuiEnabled;
+    } else if (envTuiRaw !== undefined) {
+      this.tuiEnabled = parseBooleanEnv(envTuiRaw, true);
+    } else {
+      // Default: TUI active whenever logging is not silent.
+      this.tuiEnabled = this.level !== LogLevel.SILENT;
+    }
+
+    // Quiet mode suppresses toast notifications.
+    const envQuietRaw =
+      env["OPENCODE_ANTIGRAVITY_QUIET_MODE"] ??
+      env["OPENCODE_ANTIGRAVITY_QUIET"] ??
+      env["OPENCODE_ANTIGRAVITY_SUPPRESS_TOAST"];
+    if (opts.quietMode !== undefined) {
+      this.quietMode = opts.quietMode;
+    } else {
+      this.quietMode = parseBooleanEnv(envQuietRaw, false);
+    }
+
+    this.fileLoggingEnabled = opts.enableFileLogging ?? true;
+
+    const capacity = opts.tuiCapacity ?? TUI_BUFFER_CAPACITY;
+    this.buffer = new CircularBuffer<LogEntry>(capacity);
+
+    // Best-effort boot: create dir, secure permissions, clean old logs.
+    try {
+      this.ensureLogDir();
+      this.cleanupOldLogs();
+    } catch {
+      // noop - never break the host app if fs fails at boot
+    }
+
+    // Bind for callback usage.
+    this.debug = this.debug.bind(this);
+    this.info = this.info.bind(this);
+    this.warn = this.warn.bind(this);
+    this.error = this.error.bind(this);
+  }
+
+  // -------------------------------------------------------------------------
+  // Singleton access
+  // -------------------------------------------------------------------------
+  public static getInstance(opts?: DebugLoggerOptions): DebugLogger {
+    if (!DebugLogger._instance) {
+      DebugLogger._instance = new DebugLogger(opts);
+    } else if (opts && Object.keys(opts).length > 0) {
+      // Existing instance plus explicit overrides - apply them.
+      DebugLogger._instance.applyOptions(opts);
+    }
+    return DebugLogger._instance;
+  }
+
+  /** For tests - resets the singleton. */
+  public static _resetForTests(): void {
+    DebugLogger._instance = null;
+  }
+
+  /**
+   * For testing only - resets the singleton and returns a fresh instance that
+   * reads current env. Production code should use getInstance().
+   */
+  public static resetInstanceForTests(): DebugLogger {
+    DebugLogger._instance = null;
+    return DebugLogger.getInstance();
+  }
+
+  private parseLevelOption(level: LogLevel | LogLevelName | string, fallback: LogLevel): LogLevel {
+    if (typeof level === "number") return level;
+    const low = String(level).trim().toLowerCase();
+    const mapped = LEVEL_NAME_TO_ENUM[low];
+    return mapped ?? fallback;
+  }
+
+  private applyOptions(opts: DebugLoggerOptions): void {
+    if (opts.level !== undefined) {
+      this.level = typeof opts.level === "string" ? this.parseLevelOption(opts.level, this.level) : opts.level;
+      this.enabled = this.level !== LogLevel.SILENT;
+    }
+    if (opts.tuiEnabled !== undefined) this.tuiEnabled = opts.tuiEnabled;
+    if (opts.quietMode !== undefined) this.quietMode = opts.quietMode;
+    if (opts.enableFileLogging !== undefined) this.fileLoggingEnabled = opts.enableFileLogging;
+  }
+
+  // -------------------------------------------------------------------------
+  // Getters / setters
+  // -------------------------------------------------------------------------
+  public getLevel(): LogLevel {
+    return this.level;
+  }
+
+  public getLevelName(): LogLevelName {
+    const name = LEVEL_ENUM_TO_NAME[this.level]?.toLowerCase();
+    return (name as LogLevelName) ?? "info";
+  }
+
+  /**
+   * Programmatic level setter - overrides env control for this process.
+   * Accepts enum values, level names, or any string understood by
+   * {@link parseAntigravityDebugEnv}.
+   */
+  public setLevel(level: LogLevel | LogLevelName | string): void {
+    try {
+      if (typeof level === "number") {
+        if (Object.values(LogLevel).includes(level as LogLevel)) {
+          this.level = level as LogLevel;
+          this.enabled = this.level !== LogLevel.SILENT;
+        }
+        return;
+      }
+      const low = String(level).trim().toLowerCase();
+      const mapped = LEVEL_NAME_TO_ENUM[low];
+      if (mapped !== undefined) {
+        this.level = mapped;
+        this.enabled = this.level !== LogLevel.SILENT;
+        return;
+      }
+      // Flexible parsing via the env parser (lists, wildcards, numbers).
+      const parsed = parseAntigravityDebugEnv(String(level));
+      this.level = parsed.level;
+      this.enabled = parsed.enabled;
+    } catch {
+      // ignore - setter must never throw
+    }
+  }
+
+  public isTuiEnabled(): boolean {
+    return this.tuiEnabled;
+  }
+
+  public setTuiEnabled(enabledFlag: boolean): void {
+    this.tuiEnabled = enabledFlag;
+  }
+
+  public isQuietMode(): boolean {
+    return this.quietMode;
+  }
+
+  public setQuietMode(quiet: boolean): void {
+    this.quietMode = quiet;
+  }
+
+  /**
+   * Whether toast notifications should be shown (quiet_mode suppresses them).
+   */
+  public shouldShowToast(): boolean {
+    return !this.quietMode;
+  }
+
+  public isDebugEnabled(): boolean {
+    return this.enabled && this.level <= LogLevel.DEBUG;
+  }
+
+  /** Whether file logging is currently enabled (false after disable tokens). */
+  public isEnabled(): boolean {
+    return this.enabled && this.fileLoggingEnabled;
+  }
+
+  /** Whether a given level would be emitted right now. */
+  public isLevelEnabled(lvl: LogLevel): boolean {
+    if (!this.enabled || this.level === LogLevel.SILENT) return false;
+    return lvl >= this.level;
+  }
+
+  /** Raw debug env value last observed. */
+  public getRawEnv(): string | undefined {
+    return this.rawEnv;
+  }
+
+  public getLogDir(): string {
+    return this.logDir;
+  }
+
+  public getLogFilePath(): string {
+    return this.logFile;
+  }
+
+  // -------------------------------------------------------------------------
+  // Filesystem - dir creation with hardening, rotation, retention cleanup
+  // -------------------------------------------------------------------------
+  private ensureLogDir(): void {
+    if (this.dirEnsured) return;
+    try {
+      if (!fs.existsSync(this.logDir)) {
+        fs.mkdirSync(this.logDir, { recursive: true, mode: 0o700 });
+      }
+      // Best-effort chmod 0o700 - silently ignored on Windows / restricted FS.
+      try {
+        fs.chmodSync(this.logDir, 0o700);
+      } catch {
+        // ignore chmod errors
+      }
+      this.dirEnsured = true;
+    } catch {
+      // Never propagate - logging cannot break the app.
+      this.dirEnsured = false;
+    }
+  }
+
+  /** Best-effort chmod 0o600 on the active log file. */
+  private ensureLogFilePermissions(): void {
+    try {
+      if (fs.existsSync(this.logFile)) {
+        fs.chmodSync(this.logFile, 0o600);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  private getFileSize(): number {
+    try {
+      const stat = fs.statSync(this.logFile);
+      return stat.size;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Rotates the active file when it reaches DEBUG_LOG_MAX_BYTES. Renames to
+   * antigravity-YYYY-MM-DD-HH-mm-ss-mmm.log, recreates an empty active file
+   * with mode 0o600, and falls back to truncation if rename fails.
+   */
+  private rotateIfNeeded(): void {
+    if (!this.fileLoggingEnabled) return;
+    try {
+      const size = this.getFileSize();
+      if (size < MAX_FILE_SIZE_BYTES) return;
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").replace("Z", "");
+      const rotatedName = `antigravity-${timestamp}.log`;
+      const rotatedPath = path.join(this.logDir, rotatedName);
+
+      try {
+        fs.renameSync(this.logFile, rotatedPath);
+        // Recreate a fresh empty active file with secure mode.
+        try {
+          fs.writeFileSync(this.logFile, "", { encoding: "utf8", mode: 0o600 });
+          this.ensureLogFilePermissions();
+        } catch {
+          // ignore - next append recreates it
+        }
+      } catch {
+        // If rename fails (e.g. file open elsewhere), truncate instead.
+        try {
+          fs.truncateSync(this.logFile, 0);
+        } catch {
+          // ignore
+        }
+      }
+
+      // After rotation, try retention cleanup immediately.
+      this.cleanupOldLogs(true);
+    } catch {
+      // ignore rotation errors
+    }
+  }
+
+  /**
+   * Removes rotated logs older than DEBUG_LOG_RETENTION_DAYS days.
+   * Called at boot, after rotation, and every CLEANUP_EVERY_WRITES writes;
+   * throttled to run at most once per hour unless forced.
+   */
+  public cleanupOldLogs(force = false): void {
+    const now = Date.now();
+    if (!force && now - this.lastCleanup < this.CLEANUP_INTERVAL_MS) return;
+    this.lastCleanup = now;
+
+    if (!this.fileLoggingEnabled) return;
+    try {
+      this.ensureLogDir();
+      const files = fs.readdirSync(this.logDir);
+      for (const file of files) {
+        // Only handle our own naming pattern.
+        if (!file.startsWith("antigravity") || !file.endsWith(".log")) continue;
+        // Preserve the active file.
+        if (file === LOG_FILE_NAME) continue;
+
+        const fullPath = path.join(this.logDir, file);
+        try {
+          const stat = fs.statSync(fullPath);
+          const age = now - stat.mtimeMs;
+          if (age > MAX_FILE_AGE_MS) {
+            fs.unlinkSync(fullPath);
+          }
+        } catch {
+          // Ignore individual file errors.
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Core logging pipeline
+  // -------------------------------------------------------------------------
+  private shouldLog(incomingLevel: LogLevel): boolean {
+    if (!this.enabled) return false;
+    if (this.level === LogLevel.SILENT) return false;
+    return incomingLevel >= this.level;
+  }
+
+  private formatEntry(entry: LogEntry): string {
+    const redactedMessage = redactSecretsPatterns(entry.message);
+    let line = `${entry.timestamp} [${entry.levelName}]`;
+    if (entry.scope) {
+      line += ` [${redactSecretsPatterns(entry.scope)}]`;
+    }
+    line += ` ${redactedMessage}`;
+    if (entry.data !== undefined) {
+      const json = safeStringifyMeta(entry.data);
+      line += json ? ` ${json}` : ` [unserializable data]`;
+    }
+    return line + "\n";
+  }
+
+  private writeToFile(formatted: string): void {
+    if (!this.fileLoggingEnabled) return;
+    if (this.isWriting) return; // recursion guard
+    this.isWriting = true;
+    try {
+      this.ensureLogDir();
+      this.rotateIfNeeded();
+      fs.appendFileSync(this.logFile, formatted, { encoding: "utf8", mode: 0o600 });
+      this.ensureLogFilePermissions();
+
+      // Retention check every CLEANUP_EVERY_WRITES writes (throttled internally).
+      this.writeCount++;
+      if (this.writeCount % CLEANUP_EVERY_WRITES === 0) {
+        this.cleanupOldLogs();
+      }
+    } catch {
+      // Logging failures never break the host app.
+    } finally {
+      this.isWriting = false;
+    }
+  }
+
+  private pushToTui(entry: LogEntry): void {
+    if (!this.tuiEnabled) return;
+    try {
+      this.buffer.push(entry);
+    } catch {
+      // ignore
+    }
+  }
+
+  private log(level: LogLevel, message: string, data?: unknown, scope?: string): LogEntry | null {
+    if (!this.shouldLog(level)) return null;
+
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      levelName: LEVEL_ENUM_TO_NAME[level] ?? "INFO",
+      message: String(message),
+      data,
+      scope,
+    };
+
+    // Store already-redacted copies in the TUI buffer for safety.
+    const redactedForStorage: LogEntry = {
+      ...entry,
+      message: redactSecretsPatterns(entry.message),
+      data: data !== undefined ? redactObject(data) : undefined,
+      scope: scope ? redactSecretsPatterns(scope) : undefined,
+    };
+
+    this.pushToTui(redactedForStorage);
+
+    const formatted = this.formatEntry(entry);
+    this.writeToFile(formatted);
+
+    // Stderr echo: only at DEBUG level, warn/error lines, never in quiet mode,
+    // so the opencode TUI stdout stays untouched.
+    if (this.level <= LogLevel.DEBUG) {
+      try {
+        if (typeof process !== "undefined" && process.stderr && !this.quietMode) {
+          if (level >= LogLevel.WARN) {
+            process.stderr.write(formatted);
+          }
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    return redactedForStorage;
+  }
+
+  // -------------------------------------------------------------------------
+  // Public level methods
+  // -------------------------------------------------------------------------
+  public debug(message: string, data?: unknown, scope?: string): LogEntry | null {
+    return this.log(LogLevel.DEBUG, message, data, scope);
+  }
+
+  public info(message: string, data?: unknown, scope?: string): LogEntry | null {
+    return this.log(LogLevel.INFO, message, data, scope);
+  }
+
+  public warn(message: string, data?: unknown, scope?: string): LogEntry | null {
+    return this.log(LogLevel.WARN, message, data, scope);
+  }
+
+  public error(message: string, data?: unknown, scope?: string): LogEntry | null {
+    return this.log(LogLevel.ERROR, message, data, scope);
+  }
+
+  /**
+   * Log with custom scope (useful for child loggers).
+   */
+  public withScope(scope: string): ScopedLogger {
+    return new ScopedLogger(this, scope);
+  }
+
+  // -------------------------------------------------------------------------
+  // Env refresh - long-running processes may change env at runtime
+  // -------------------------------------------------------------------------
+  /**
+   * Re-reads OPENCODE_ANTIGRAVITY_DEBUG (or ANTIGRAVITY_DEBUG) and updates
+   * the enabled flag and level accordingly.
+   *
+   * @param env - optional env override (defaults to process.env)
+   * @returns the fresh parse result
+   */
+  public refreshFromEnv(env: NodeJS.ProcessEnv = process.env): EnvParseResult {
+    try {
+      const raw = readFirstEnv(env, ["OPENCODE_ANTIGRAVITY_DEBUG", "ANTIGRAVITY_DEBUG"]);
+      const parsed = parseAntigravityDebugEnv(raw);
+      this.enabled = parsed.enabled;
+      this.level = parsed.level;
+      this.rawEnv = raw;
+      return parsed;
+    } catch {
+      return { enabled: this.enabled, level: this.level, raw: this.rawEnv };
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // TUI API
+  // -------------------------------------------------------------------------
+  public getTuiBuffer(): LogEntry[] {
+    return this.buffer.toArray();
+  }
+
+  public getRecentLogs(count: number): LogEntry[] {
+    return this.buffer.getRecent(count);
+  }
+
+  public getTuiBufferAsString(maxLines?: number): string {
+    const entries = maxLines ? this.buffer.getRecent(maxLines) : this.buffer.toArray();
+    return entries
+      .map((e) => {
+        const scopePart = e.scope ? ` [${e.scope}]` : "";
+        const dataPart = e.data !== undefined ? ` ${JSON.stringify(e.data)}` : "";
+        return `${e.timestamp} [${e.levelName}]${scopePart} ${e.message}${dataPart}`;
+      })
+      .join("\n");
+  }
+
+  public clearTuiBuffer(): void {
+    this.buffer.clear();
+  }
+
+  public getTuiBufferSize(): number {
+    return this.buffer.size;
+  }
+
+  public getTuiCapacity(): number {
+    return this.buffer.capacity;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Section: Scoped logger (per-module child loggers, e.g. auth:refresh)
+// ---------------------------------------------------------------------------
+export class ScopedLogger {
+  constructor(
+    private readonly parent: DebugLogger,
+    private readonly scope: string,
+  ) {}
+
+  debug(message: string, data?: unknown): LogEntry | null {
+    return this.parent.debug(message, data, this.scope);
+  }
+  info(message: string, data?: unknown): LogEntry | null {
+    return this.parent.info(message, data, this.scope);
+  }
+  warn(message: string, data?: unknown): LogEntry | null {
+    return this.parent.warn(message, data, this.scope);
+  }
+  error(message: string, data?: unknown): LogEntry | null {
+    return this.parent.error(message, data, this.scope);
+  }
+
+  withScope(childScope: string): ScopedLogger {
+    return new ScopedLogger(this.parent, `${this.scope}:${childScope}`);
+  }
+
+  get parentLogger(): DebugLogger {
+    return this.parent;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Section: Default singleton and functional helpers
+// ---------------------------------------------------------------------------
+function getLogger(): DebugLogger {
+  return DebugLogger.getInstance();
+}
+
+export const logger: DebugLogger = DebugLogger.getInstance();
+
+/** Direct-import level helpers: import { debug, info } from "./debug" */
+export function debug(message: string, data?: unknown, scope?: string): LogEntry | null {
+  return getLogger().debug(message, data, scope);
+}
+export function info(message: string, data?: unknown, scope?: string): LogEntry | null {
+  return getLogger().info(message, data, scope);
+}
+export function warn(message: string, data?: unknown, scope?: string): LogEntry | null {
+  return getLogger().warn(message, data, scope);
+}
+export function error(message: string, data?: unknown, scope?: string): LogEntry | null {
+  return getLogger().error(message, data, scope);
+}
+
+/** Creates a scoped logger (e.g. "auth:gemini", "plugin:load"). */
+export function createScopedLogger(scope: string): ScopedLogger {
+  return getLogger().withScope(scope);
+}
+
+/** Compatibility alias for createScopedLogger. */
+export function createDebugLogger(scope: string): ScopedLogger {
+  return createScopedLogger(scope);
+}
+
+/** State helpers controlled by env. */
+export function isDebugEnabled(): boolean {
+  return getLogger().isDebugEnabled();
+}
+export function isTuiEnabled(): boolean {
+  return getLogger().isTuiEnabled();
+}
+export function isQuietMode(): boolean {
+  return getLogger().isQuietMode();
+}
+export function shouldShowToast(): boolean {
+  return getLogger().shouldShowToast();
+}
+
+/** TUI buffer access helpers. */
+export function getTuiBuffer(): LogEntry[] {
+  return getLogger().getTuiBuffer();
+}
+export function getRecentLogs(n: number): LogEntry[] {
+  return getLogger().getRecentLogs(n);
+}
+export function getTuiBufferAsString(maxLines?: number): string {
+  return getLogger().getTuiBufferAsString(maxLines);
+}
+export function clearTuiBuffer(): void {
+  return getLogger().clearTuiBuffer();
+}
+
+/** Log filesystem info helpers. */
+export function getLogDir(): string {
+  return getLogger().getLogDir();
+}
+export function getLogFilePathExport(): string {
+  return getLogger().getLogFilePath();
+}
+
+/** Dynamic adjustment helpers (useful for TUI commanders). */
+export function setLogLevel(level: LogLevel | LogLevelName): void {
+  getLogger().setLevel(level);
+}
+export function setQuietMode(enabledFlag: boolean): void {
+  getLogger().setQuietMode(enabledFlag);
+}
+export function setTuiEnabled(enabledFlag: boolean): void {
+  getLogger().setTuiEnabled(enabledFlag);
+}
+
+/**
+ * Functional wrapper around {@link DebugLogger.refreshFromEnv}: re-reads the
+ * debug env variables and applies them to the singleton logger.
+ */
+export function refreshFromEnv(env?: NodeJS.ProcessEnv): EnvParseResult {
+  return env ? getLogger().refreshFromEnv(env) : getLogger().refreshFromEnv();
+}
+
+// ---------------------------------------------------------------------------
+// Default export - the DebugLogger class (construct your own instances).
+// The shared singleton is available as the named export `logger`.
+// ---------------------------------------------------------------------------
+export default DebugLogger;
+
+// ===========================================================================
+// v2.1.15 Phase B: logging trio moved from config.ts (values verbatim —
+// the published ./system subpath semantics: "Bearer [REDACTED]" style)
+// ===========================================================================
+
+/** Antigravity debug-logs directory inside the config directory. */
+export const logsDir = (): string => path.join(cfgDir(), "antigravity-logs");
+
+/** Redacts Bearer JWTs and refresh_token substrings from a log line. */
+export const redactSecrets = (s: string): string =>
+  s
+    .replace(/Bearer\s+[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+/g, "Bearer [REDACTED]")
+    .replace(/refresh_token[^\s]*/gi, "refresh_token=[REDACTED]");
+
+/**
+ * Mini debug-logger singleton: 1000-line ring buffer, daily log files under
+ * logsDir(), 10MB rotation, 7-day cleanup, secret redaction on every line.
+ */
+export class debugLogger {
+  private static inst: debugLogger | null = null;
+  private buffer: string[] = [];
+  private maxBuf = 1000;
+  static get(): debugLogger {
+    if (!debugLogger.inst) debugLogger.inst = new debugLogger();
+    return debugLogger.inst!;
+  }
+  log(msg: string): void {
+    const line = `[${new Date().toISOString()}] ${redactSecrets(msg)}`;
+    this.buffer.push(line);
+    if (this.buffer.length > this.maxBuf) this.buffer.shift();
+    try {
+      fs.mkdirSync(logsDir(), { recursive: true });
+      const p = path.join(logsDir(), `antigravity-${new Date().toISOString().slice(0, 10)}.log`);
+      fs.writeFileSync(p, this.buffer.join("\n") + "\n", { flag: "a" });
+      const st = fs.statSync(p);
+      if (st.size > 10 * 1024 * 1024) {
+        const bak = `${p}.1`;
+        try {
+          fs.renameSync(p, bak);
+        } catch {
+          /* the guarded best-effort operation falls through: the outer flow owns the failure */
+        }
+      }
+    } catch {
+      /* the guarded best-effort operation falls through: the outer flow owns the failure */
+    }
+  }
+  getBuffer(): string[] {
+    return [...this.buffer];
+  }
+  cleanup(): void {
+    try {
+      const files = fs.readdirSync(logsDir());
+      const now = Date.now();
+      for (const f of files) {
+        const fp = path.join(logsDir(), f);
+        try {
+          const st = fs.statSync(fp);
+          if (now - st.mtimeMs > 7 * 24 * 3600 * 1000) fs.unlinkSync(fp);
+        } catch {
+          /* the guarded best-effort operation falls through: the outer flow owns the failure */
+        }
+      }
+    } catch {
+      /* the guarded best-effort operation falls through: the outer flow owns the failure */
+    }
+  }
+}